Analyse von Java-Stacks und Warteschlangeninstanzen
- 王林nach vorne
- 2023-05-10 16:40:151325Durchsuche
Stack
package com.yuzhenc.collection;
import java.util.Stack;
/**
* @author: yuzhenc
* @date: 2022-03-20 15:41:36
* @desc: com.yuzhenc.collection
* @version: 1.0
*/
public class Test26 {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.add("A");
stack.add("B");
stack.add("C");
stack.add("D");
System.out.println(stack);//[A, B, C, D]
//判断栈是否为空
System.out.println(stack.empty());//false
//查看栈顶元素，不会移除
System.out.println(stack.peek());//D
System.out.println(stack);//[A, B, C, D]
//查看栈顶元素，并且移除，即出栈（先进后出）
System.out.println(stack.pop());//D
System.out.println(stack);//[A, B, C]
//入栈，和add方法执行的功能一样，就是返回值不同
System.out.println(stack.push("E"));//返回入栈的元素 E
System.out.println(stack);//[A, B, C, E]
}
}queue
Blocking queue
- # 🎜🎜#
-
ArrayBlockingQueue: Unterstützt keine gleichzeitigen Lese- und Schreibvorgänge, die unterste Ebene basiert auf Arrays; code>LinkedBlockingQueuecode>: Unterstützt gleichzeitige Lese- und Schreibvorgänge, hohe Effizienz unter gleichzeitigen Bedingungen und die unterste Ebene basiert auf einer verknüpften Liste;SynchronousQueue: Bequem und effizient Die Übertragung von Daten zwischen Threads führt nicht zu Datenkonflikten in der Warteschlange. Code>: Prioritätsblockierungswarteschlange;# 🎜🎜#ArrayBlockingQueue： 不支持读写同时操作，底层基于数组的； LinkedBlockingQueue：支持读写同时操作，并发情况下，效率高，底层基于链表；
package com.yuzhenc.collection;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* @author: yuzhenc
* @date: 2022-03-20 16:00:22
* @desc: com.yuzhenc.collection
* @version: 1.0
*/
public class Test27 {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
//添加元素
//不可以添加null，报空指针异常
//arrayBlockingQueue.add(null);
//arrayBlockingQueue.offer(null);
//arrayBlockingQueue.put(null);
//正常添加元素
System.out.println(arrayBlockingQueue.add("Lili"));//true
System.out.println(arrayBlockingQueue.offer("Amy"));//true
arrayBlockingQueue.put("Nana");//无返回值
//队列满的情况下添加元素
//arrayBlockingQueue.add("Sam");//报非法的状态异常
//设置最大注阻塞时间，如果时间到了队列还是满的，就不再阻塞了
arrayBlockingQueue.offer("Daming", 3,TimeUnit.SECONDS);
System.out.println(arrayBlockingQueue);//[Lili, Amy, Nana]
//真正阻塞的方法，如果队列一直是满的，就一直阻塞
//arrayBlockingQueue.put("Lingling");//运行到这永远走不下去了，阻塞了
//获取元素
//获取队首元素不移除
System.out.println(arrayBlockingQueue.peek());//Lili
//出队，获取队首元素并且移除
System.out.println(arrayBlockingQueue.poll());//Lili
System.out.println(arrayBlockingQueue);//[Amy, Nana]
//获取队首元素，并且移除
System.out.println(arrayBlockingQueue.take());//Amy
System.out.println(arrayBlockingQueue);//[Nana]
//清空元素
arrayBlockingQueue.clear();
System.out.println(arrayBlockingQueue);//[]
System.out.println(arrayBlockingQueue.peek());
System.out.println(arrayBlockingQueue.poll());
//设置阻塞事件，如果队列为空，返回null，时间到了以后就不阻塞了
System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
//真正的阻塞，队列为空
//System.out.println(arrayBlockingQueue.take());//执行到这里走不下去了
}
}SynchronousQueue：方便高效地进行线程间数据的传送，不会产生队列中数据争抢问题；
package com.yuzhenc.collection;
import java.util.concurrent.SynchronousQueue;
/**
* @author: yuzhenc
* @date: 2022-03-20 21:06:47
* @desc: com.yuzhenc.collection
* @version: 1.0
*/
public class Test28 {
public static void main(String[] args) {
SynchronousQueue sq = new SynchronousQueue();
//创建一个线程，取数据：
new Thread(new Runnable() {
@Override
public void run() {
while(true){
try {
System.out.println(sq.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
//搞一个线程，往里面放数据：
new Thread(new Runnable() {
@Override
public void run() {
try {
sq.put("aaa");
sq.put("bbb");
sq.put("ccc");
sq.put("ddd");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}PriorityBlockingQueue：带优先级的阻塞队列；无界的队列，没有长度限制，但是在你不指定长度的时候，默认初始长度为11，也可以手动指定，当然随着数据不断的加入，底层（底层是数组Object[]）会自动扩容，直到内存全部消耗殆尽了，导致 OutOfMemoryError内存溢出 程序才会结束；
不可以放入null元素的，不允许放入不可比较的对象（导致抛
ClassCastException），对象必须实现内部比较器或者外部比较器；
package com.yuzhenc.collection;
import java.util.concurrent.PriorityBlockingQueue;
/**
* @author: yuzhenc
* @date: 2022-03-20 21:16:56
* @desc: com.yuzhenc.collection
* @version: 1.0
*/
public class Test29 {
public static void main(String[] args) throws InterruptedException {
PriorityBlockingQueue<Human> priorityBlockingQueue = new PriorityBlockingQueue<>();
priorityBlockingQueue.put(new Human("Lili",25));
priorityBlockingQueue.put(new Human("Nana",18));
priorityBlockingQueue.put(new Human("Amy",38));
priorityBlockingQueue.put(new Human("Sum",9));
//没有按优先级排列
System.out.println(priorityBlockingQueue);//[Human{name='Sum', age=9}, Human{name='Nana', age=18}, Human{name='Amy', age=38}, Human{name='Lili', age=25}]
//出列的时候按优先级出列
System.out.println(priorityBlockingQueue.take());//Human{name='Sum', age=9}
System.out.println(priorityBlockingQueue.take());//Human{name='Nana', age=18}
System.out.println(priorityBlockingQueue.take());//Human{name='Lili', age=25}
System.out.println(priorityBlockingQueue.take());//Human{name='Amy', age=38}
}
}
class Human implements Comparable <Human> {
String name;
int age;
public Human() {}
public Human(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Human{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Human o) {
return this.age-o.age;
}-
Unbegrenzte Warteschlange, es gibt keine Längenbeschränkung, aber wenn Sie die Länge nicht angeben, beträgt die Standardanfangslänge 11 Geben Sie es auch manuell an. Wenn weiterhin Daten hinzugefügt werden, wird die unterste Ebene (die unterste Ebene ist das Array Object []) automatisch erweitert, bis der gesamte Speicher verbraucht ist, was zu einem OutOfMemoryError-Speicherüberlauf führt. Das Programm wird nicht beendet.DelayQueue：DelayQueue是一个无界的BlockingQueue -
kann nicht gesetzt werden. Bei der Eingabe von Nullelementen sind nicht vergleichbare Objekte nicht zulässig (was zum Auslösen einer
ClassCastExceptionführt). Das Objekt muss einen internen Komparator implementieren oder ein externer Vergleicher; >, wird zum Platzieren von Objekten verwendet, die die verzögerte Schnittstelle implementieren. Die darin enthaltenen Objekte können nur dann aus der Warteschlange entnommen werden, wenn sie ablaufen Ruft eine Methode wie put auf, um ein Element hinzuzufügen, wird die Methode „compareTo“ in der Schnittstelle „Delayed“ ausgelöst. Das bedeutet, dass die Reihenfolge der Elemente in der Warteschlange nach der Ablaufzeit sortiert wird, nicht nach der Reihenfolge, in der sie eingegeben wurden in die Warteschlange. Das Element an der Spitze der Warteschlange läuft am frühesten ab und die Ablaufzeit ist umso später; . Beachten Sie, dass die Anzeige nicht abgeschlossen ist. Rufen Sie dann die getDelay-Methode des Elements auf. Wenn der von dieser Methode zurückgegebene Wert kleiner als 0 oder gleich 0 ist, nimmt der Verbraucherthread das Element aus der Warteschlange und verarbeitet es. Wenn der von der getDelay-Methode zurückgegebene Wert größer als 0 ist, entfernt der Verbraucherthread das Element aus dem Kopf der Warteschlange, nachdem der von wait zurückgegebene Zeitwert abgelaufen ist. 🎜🎜# #🎜 🎜#Sie können keine Nullelemente in diese Warteschlange stellen. 🎜🎜#Taobao-Bestellgeschäft: Wenn innerhalb von dreißig Minuten nach der Bestellung keine Zahlung erfolgt, wird die Bestellung automatisch storniert # - Haben Sie Hunger? 60 Sekunden nach erfolgreicher Bestellung senden Sie eine SMS-Benachrichtigung an den Benutzer. Schließen Sie die inaktive Verbindung. Auf dem Server gibt es viele Client-Verbindungen, die nach einer gewissen Zeit im Leerlauf geschlossen werden müssen. Objekte im Cache müssen nach Ablauf der Leerlaufzeit aus dem Cache entfernt werden. Wenn Sie eine reaktionsfähige Interaktion im Netzwerkprotokoll-Schiebefenster anfordern, behandeln Sie nicht reagierende Anfragen usw. wegen Zeitüberschreitung. 🎜#Double-Ended Queue
package com.yuzhenc.collection; import java.util.concurrent.DelayQueue; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * @author: yuzhenc * @date: 2022-03-20 21:43:32 * @desc: com.yuzhenc.collection * @version: 1.0 */ public class Test30 { //创建一个队列： DelayQueue<User> dq = new DelayQueue<>(); //登录游戏： public void login(User user){ dq.add(user); System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]已经登录，预计下机时间为：" + user.getEndTime() ); } //时间到，退出游戏，队列中移除： public void logout(){ //打印队列中剩余的人： System.out.println(dq); try { User user = dq.take(); System.out.println("用户：[" + user.getId() +"],[" + user.getName() + "]上机时间到，自动退出游戏"); } catch (InterruptedException e) { e.printStackTrace(); } } //获取在线人数： public int onlineSize(){ return dq.size(); } //这是main方法，程序的入口 public static void main(String[] args) { //创建测试类对象： Test30 test = new Test30(); //添加登录的用户： test.login(new User(1,"张三",System.currentTimeMillis()+5000)); test.login(new User(2,"李四",System.currentTimeMillis()+2000)); test.login(new User(3,"王五",System.currentTimeMillis()+10000)); //一直监控 while(true){ //到期的话，就自动下线： test.logout(); //队列中元素都被移除了的话，那么停止监控，停止程序即可 if(test.onlineSize() == 0){ break; } } } } class User implements Delayed { private int id;//用户id private String name;//用户名字 private long endTime;//结束时间 public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public long getEndTime() { return endTime; } public void setEndTime(long endTime) { this.endTime = endTime; } public User(int id, String name, long endTime) { this.id = id; this.name = name; this.endTime = endTime; } //只包装用户名字就可以 @Override public String toString() { return "User{" + "name='" + name + '\'' + '}'; } @Override public long getDelay(TimeUnit unit) { //计算剩余时间 剩余时间小于0 <=0 证明已经到期 return this.getEndTime() - System.currentTimeMillis(); } @Override public int compareTo(Delayed o) { //队列中数据 到期时间的比较 User other = (User)o; return ((Long)(this.getEndTime())).compareTo((Long)(other.getEndTime())); } }
Das obige ist der detaillierte Inhalt vonAnalyse von Java-Stacks und Warteschlangeninstanzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Stellungnahme：
Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen