Getting to know the Queue queue

1. wait and notify simulate Queue

1.1 basic knowledge of wait / notify

Thread communication concept: Threads are independent individuals in the operating system, but these individuals cannot become a whole without special treatment, and communication between threads has become one of the necessary methods for the whole.

Use the wait/notify methods to communicate between threads:

1) wait and notify must be used with the synchronized keyword

2) The wait method releases the lock, and the notify method does not release the lock.

1.2 wait / notify 模拟BlockingQueue

BlockingQueue: It is a queue and supports blocking mechanism, blocking put and get data. We want to implement LinkedBlockingQueue The following two simple methods put and take

put(an object): Add an object to the BlockingQueue. If there is no space in the BlockingQueue, the thread calling this method will be blocked until there is space in the BlockingQueue to continue.

take: Take the object ranked first in the BlockingQueue. If the BlockingQueue is empty, block entering the waiting state until the BlockingQueue has new data added.

[java] view plain copy

import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class MyQueue {
//1 requires a collection of holding elements
private LinkedList<Object> list = new LinkedList<Object>();
//2 requires a counter AtomicInteger (atomicity)
private AtomicInteger count = new AtomicInteger(0);
//3 Need to set upper and lower bounds
private final int minSize = 0;
private final int maxSize ;
//4 Constructor
public MyQueue(int size){
this.maxSize = size;
}
//5 Initialize an object for locking
private final Object lock = new Object();
//put(anObject): Add anObject to the BlockingQueue. If the BlockQueue has no space, the thread calling this method will be blocked until there is space in the BlockingQueue to continue.
public void put(Object obj){
synchronized (lock) {
while(count.get() == this.maxSize){
try {
lock.wait(); // When the Queue has no space, the thread is blocked
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
//1 add element
list.add(obj);
//2 count up
count.incrementAndGet();
//3 After adding an element, notify another thread (wake up), and there is one more element in the queue, which can be removed.
lock.notify();
System.out.println("The newly added element is: " + obj);
}
}
//take: Take the object ranked first in the BlockingQueue. If the BlockingQueue is empty, block and enter the waiting state until the BlockingQueue has new data added.
public Object take(){
Object ret = null;
synchronized (lock) {
while(count.get() == this.minSize){
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
//1 do the element removal operation
ret = list.removeFirst();
//2 counter decrements
count.decrementAndGet();
//3 After removing the element, wake up another thread, the queue has fewer elements, and the operation can be added again
lock.notify();
}
return ret;
}
public int getSize(){
return this.count.get();
}
public static void main(String[] args) {
final MyQueue mq = new MyQueue(5);
mq.put("a");
mq.put("b");
mq.put("c");
mq.put("d");
mq.put("e");
System.out.println("Length of current container: " + mq.getSize());
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
mq.put("f");
mq.put("g");
}
},"t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
Object o1 = mq.take();
System.out.println("The removed element is: " + o1);
Object o2 = mq.take();
System.out.println("The removed element is: " + o2);
}
},"t2");
t1.start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace ();
}
t2.start();
}
}

It can be seen from the printed information that when the t2 thread removes the data, the t1 thread starts to add data

2. Concurrent Queue

2.1 Introduction to Queue

The main implementation of Queue is shown in the following figure. Queue is mainly divided into two categories, one is the high-performance queue ConcurrentLinkedQueue; the other is the blocking queue BlockingQueue

2.2 ConcurrentLinkedQueue interface

ConcurrentLinkedQueue: It is a queue suitable for high concurrency scenarios. It achieves high performance under high concurrency in a lock-free manner. Usually, ConcurrentLinkedQueue has better performance than BlockingQueue. It is an unbounded thread-safe queue based on linked nodes. The elements of this queue follow the principle of first-in, first-out. The head is added first and the tail is added last. The queue does not allow null elements.

Important methods of ConcurrentLinkedQueue:

Both add() and offer() are adding elements, and there is no difference in the queue

Both poll() and peek() take the head element node, the difference is that the former will delete the element, the latter will not

[java] view plain copy

import java.util.concurrent.ConcurrentLinkedQueue;
public class MyConcurrentLinkedQueue {
public static void main(String[] args) throws Exception {
//High-performance non-blocking unbounded queue: ConcurrentLinkedQueue
ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<String>();
q.offer("a");
q.offer("b");
q.offer("c");
q.offer("d");
q.add("e");
System.out.println(q.poll()); // print result: a (take the element from the head and delete it from the queue)
System.out.println(q.size()); // print result: 4 (the element is reduced by one after poll is executed)
System.out.println(q.peek()); // print result: b (a is removed, the first element is b)
System.out.println(q.size()); // print result: 4 (peek does not remove elements)
}
}

2.3 BlockingQueue interface

ArrayBlockingQueue: Array-based blocking queue implementation, internally, maintains a fixed-length array to cache data objects in the queue. It does not implement read-write separation internally, which means that production and consumption cannot be completely parallel. The length needs to be defined, you can specify FIFO or FIFO, it is a bounded queue.

[java] view plain copy

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class MyArrayBlockingQueue {
public static void main(String[] args) throws Exception {
ArrayBlockingQueue<String> array = new ArrayBlockingQueue<String>(5); // You can try to change the queue length from 3 to 5
array.offer("offer method returns true if the data is inserted successfully, otherwise returns false");
array.offer("Insert data after 3 seconds", 3, TimeUnit.SECONDS);
array.put("put method will block waiting if it exceeds the length");
array.add("add method will prompt error message when the length exceeds java.lang.IllegalStateException"); // java.lang.IllegalStateException: Queue full
System.out.println(array.offer("true or false", 3, TimeUnit.SECONDS));
System.out.println(array);
}
}

LinkedBlockingQueue: List-based blocking queue, similar to ArrayBlockingQueue, it maintains a data buffer queue (the queue is composed of a linked list). The reason why it can efficiently process concurrent data is that its internal implementation adopts separate locks (read and write). Separating the two locks), allowing for fully parallel running of producer and consumer operations. is an unbounded queue

The usage is similar to ArrayBlockingQueue, offer, put, add. The difference is that LinkedBlockingQueue is an unbounded queue. When initializing, you can set a length or not. The drainTo(collection, maximum length of the collection) method can intercept the length from the LinkedBlockingQueue to another collection.

SynchronousQueue: An unbuffered queue, the data produced by the survivor will be directly acquired and consumed by the consumer.

What scenarios are the above three queues used for? For example: take the subway. When there are few people, when swiping the card, one person can swipe directly without waiting. This uses SynchronousQueue. During the rush hour, there are a lot of people. When you swipe your card, you need to queue up. This uses the LinkedBlockingQueue unbounded queue. The peak holiday season is full of people. If the LinkedBlockingQueue is used, it is unbounded. If too many people come in, it will affect the normal work of the subway station. At this time, the bounded queue ArrayBlockingQueue should be used.

PriorityBlockingQueue: priority-based blocking queue (priority judgment is determined by the Compator object passed in by the constructor, that is to say, the object passed into the queue must implement the Comparable interface). When implementing PriorityBlockingQueue, the internal control thread synchronization lock adopts is a fair lock, which is an unbounded queue.

The object passed into the queue: Task

[java] view plain copy

public class Task implements Comparable<Task>{
private int id ;
private String name;
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;
}
@Override
public int compareTo(Task task) {
return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);
}
public String toString(){
return this.id + "," + this.name;
}
}

PriorityBlockingQueue ordering:

[java] view plain copy

import java.util.concurrent.PriorityBlockingQueue;
public class MyPriorityBlockingQueue {
public static void main(String[] args) throws Exception{
PriorityBlockingQueue<Task> q = new PriorityBlockingQueue<Task>();
// set from large to small
Task t1 = new Task();
t1.setId (1);
t1.setName("id为1");
Task t2 = new Task();
t2.setId(4);
t2.setName("id为4");
Task t3 = new Task();
t3.setId(9);
t3.setName("id为9");
Task t4 = new Task();
t4.setId(16);
t4.setName("id为16");
Task t5 = new Task();
t5.setId(5);
t5.setName("id为5");
// Deliberately disrupt the order into the queue
q.add(t3);
q.add(t4);
q.add(t1);
q.add(t2);
q.add(t5);
System.out.println("Initial queue container: " + q);
System.out.println("The first element: " + q.take()); // Sort after take (sort output after taking value)
System.out.println("Container after executing take method: " + q);
}
}

DelayQueue: A Queue with a delay time. The element can only be obtained from the queue when the specified delay time is reached. The elements in the DelayQueue must implement the Delayed interface. DelayQueue is a queue with no size limit. There are many application scenarios. ,

For example, removing cached timeout data, task timeout processing, closing idle connections, etc.

Excerpt from online code:

[java] view plain copy

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class Wangmin implements Delayed {
private String name;
//ID card
private String id;
//deadline
private long endTime;
//Define the time tool class
private TimeUnit timeUnit = TimeUnit.SECONDS;
public Wangmin(String name,String id,long endTime){
this.name=name;
this.id=id;
this.endTime = endTime;
}
public String getName(){
return this.name;
}
public String getId(){
return this.id;
}
/**
* Used to determine whether the deadline is reached
*/
@Override
public long getDelay(TimeUnit unit) {
//return unit.convert(endTime, TimeUnit.MILLISECONDS) - unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
return endTime - System.currentTimeMillis();
}
/**
* For mutual batch comparison and sorting
*/
@Override
public int compareTo(Delayed delayed) {
Wangmin w = (Wangmin)delayed;
return this.getDelay(this.timeUnit) - w.getDelay(this.timeUnit) > 0 ? 1:0;
}
}

[java] view plain copy

import java.util.concurrent.DelayQueue;
public class WangBa implements Runnable {
private DelayQueue<Wangmin> queue = new DelayQueue<Wangmin>();
public boolean yinye =true;
public void shangji(String name,String id,int money){
Wangmin man = new Wangmin(name, id, 1000 * money + System.currentTimeMillis());
System.out.println("screen name"+man.getName()+"ID card"+man.getId()+"payment"+money+"block, start on the machine...");
this.queue.add(man);
}
public void xiaji(Wangmin man){
System.out.println("Screen name"+man.getName()+"ID card"+man.getId()+"Time to get off the plane...");
}
@Override
public void run() {
while(yinye){
try {
Wangmin man = queue.take();
xiaji(man);
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
}
public static void main(String args[]){
try{
System.out.println("Internet cafes are open for business");
WangBa siyu = new WangBa();
Thread shangwang = new Thread(siyu);
shangwang.start();
siyu.shangji("Passenger A", "123", 1);
siyu.shangji("Passerby B", "234", 10);
siyu.shangji("Passenger C", "345", 5);
}
catch(Exception e){
e.printStackTrace ();
}
}
}

Getting to know the Queue queue

For example, removing cached timeout data, task timeout processing, closing idle connections, etc.

Guess you like