What is SynchronousQueue in java

Function Description

To understand SynchronousQueue, you must first know its function. Only by knowing the purpose of this class and the functions it provides can you not get lost when reading the source code.

In our previous study, if threads want to exchange data, they usually use a public variable or a synchronous blocking queue. The producer thread sets the variable or puts the value into the queue, and the consumer thread The thread reads the variable or take from the queue.

SynchronousQueue does not need to store the data exchanged between threads. It functions more like a matcher to match producers and consumers one by one.

General process

For example, when a thread calls the put method and finds that there is no take thread in the queue, the put thread will block. When the take thread comes in, it is found that If there is a blocked put thread, then the two of them will match, and then the take thread will obtain the data of the put thread, and neither thread will be blocked.

On the contrary, a thread calling the take method will also block the thread. When a thread calling the put method comes in, it will also match it.

If a take or put thread comes in and finds that a take or put thread of the same type is blocked, then the thread will be queued to the back until a thread of a different type comes in and matches one of the threads .

Through the process description, I believe that I have a certain understanding of SynchronousQueue, and I also know why SynchronousQueue does not need to store elements.

Source code analysis

By looking at the take and put methods of SynchronousQueue, we found that they are both called the transfer method of an attribute transferer, and the transferer attribute is Abstract static inner class Transferer of SynchronousQueue. Transferer has two subclasses, TransferQueue and TransferStack;

In the SynchronousQueue constructor, the passed parameter fair is used to determine whether to create TransferQueue or TransferStack. According to the parameter fair, TransferQueue should be in fair mode, then TransferStack is a non-functional mode. .

Fair mode TransferQueue implementation

First of all, it has an internal class QNode. Through the above analysis, it is found that there may be multiple consumers or multiple producers, and they will Form a queue, and QNode is a linked list used to form a queue.

QNode mainly has four attributes:

QNode next: represents the next node;

Object item; here is actually the data put out, the node generated by the take method Here is null;

Thread waiter; The blocked thread is usually blocked by the thread that generated this node. Other threads will wake up after getting the data;

boolean isData: true means put generation , false means it is generated by take;

Since both take and put depend on the transfer method, let’s look at the implementation of transfer. The source code is too long so I won’t post it. Just look at the summarized flow chart:

Because this method does not use locks for control, there are still many judgments in the entire process. These are secondary. Here are the main and key processes.

To briefly explain, the entire process relies on the QNode linked list. The isData of QNode distinguishes the take or put method. The isData of the nodes in the linked list must be the same. The items of QNode are take and put threads. The data exchanged, except that the data exchanged by the take method is null.

It can be seen that every time it can be matched, the front node is taken in and the data is returned.

Unfair Mode TransferStack

Similarly, TransferStack also has a linked list structure called SNode. The main attributes of SNode are as follows:

SNode next: the next node;

SNode match: The successfully matched node;

Thread waiter: blocked thread;

Object item: the value to be given;

int mode: Node classification, used to distinguish put or take;

The source code flow chart of transfer is also organized, as shown below:

They are also implemented using linked lists, but this one has a different structure. There is an extra match to represent the matching node.

Through the process, you can see that mode has three values. In addition to 0 and 1, there is also a 2 to represent the node being matched. Mainly in the red box part in the above picture, when finds that the head node is not in progress, the current thread will create a matching node, then add it to the head, and finally match it with the following nodes .

If a match is found, the matching node will be removed from the linked list.

Through process analysis, it can be seen that TransferStack is placed at the head of the thread that comes in later, and will be matched first.

The above is the detailed content of What is SynchronousQueue in java. For more information, please follow other related articles on the PHP Chinese website!