Using Java's blockingqueue to implement producer-consumer

Blockingqueue is also the main tool for controlling thread synchronization under Java.util.concurrent.

Blockingqueue has four specific implementation classes, depending on the needs, choose different implementation classes
1, Arrayblockingqueue: a bounded block queue supported by an array, specifying the size of the Blockingqueue, its constructor must take an int parameter to indicate its size. The objects it contains are sorted in FIFO (first in, first out) order.

2, Linkedblockingqueue: The size of the variable blockingqueue, if its constructor with a specified size parameters, the resulting blockingqueue has a size limit, if not with the size of parameters, The size of the generated blockingqueue is determined by Integer.max_value. The objects it contains are sorted in FIFO (first in, first out) order.

3. Priorityblockingqueue: Similar to Linkedblockqueue, but the sort of objects it contains is not FIFO, but is determined by the natural sort order of the object or the comparator of the constructor.

4, Synchronousqueue: Special Blockingqueue, the operation of its must be put and take alternating completion.

Linkedblockingqueue can specify the capacity, or can not specify, if not specified, the default maximum is Integer.max_value, which is mainly used in the put and take method, the put method is blocked when the queue is full until a queue member is consumed, The Take method blocks when the queue is empty until a queue member is put in.

Sample code for producer consumers:

Producers:

Java code

2. import java.util.concurrent.BlockingQueue;
6. Public class Producer implements Runnable {
8. Blockingqueue<string> queue;
12. Public Producer (blockingqueue<string> queue) {
14. this. Queue = queue;
16. }
20. @Override
22. Public void Run () {
24. Try {
26. String temp = "A product, production line:"
28. + Thread.CurrentThread (). GetName ();
30. System.out.println ("I have made a product:"
32. + Thread.CurrentThread (). GetName ());
34. Queue.put (temp); //If the queue is full, it will block the current thread
36. } catch (Interruptedexception e) {
38. E.printstacktrace ();
40. }
42. }
46. }

Import Java.util.concurrent.blockingqueue;public class Producer implements Runnable {blockingqueue<string> Queue;public Producer (blockingqueue<string> queue) {this.queue = queue;} @Overridepublic void Run () {try {String temp = "A product, Production line:" + thread.currentthread (). GetName (); System.out.println ("I have made a product:" + thread.currentthread (). GetName ()); Queue.put (temp);//If the queue is full, it blocks the current thread} catch (Interruptedexception e) {e.printstacktrace ();}}}

Consumers:

Java code

2. import java.util.concurrent.BlockingQueue;
6. Public class Consumer implements runnable{
8. Blockingqueue<string> queue;
12. Public Consumer (blockingqueue<string> queue) {
14. this. Queue = queue;
16. }
20. @Override
22. Public void Run () {
24. Try {
26. String temp = Queue.take (); //If the queue is empty, the current thread is blocked
28. SYSTEM.OUT.PRINTLN (temp);
30. } catch (Interruptedexception e) {
32. E.printstacktrace ();
34. }
36. }
38. }

Import Java.util.concurrent.blockingqueue;public class Consumer implements Runnable{blockingqueue<string> Queue;public Consumer (blockingqueue<string> queue) {this.queue = queue;} @Overridepublic void Run () {try {String temp = Queue.take ();//If the queue is empty, it blocks the current thread System.out.println (temp);} catch ( Interruptedexception e) {e.printstacktrace ();}}}

Test class:

Java code

2. import java.util.concurrent.ArrayBlockingQueue;
4. import java.util.concurrent.BlockingQueue;
6. import java.util.concurrent.LinkedBlockingQueue;
10. Public class TEST3 {
14. Public Static void Main (string[] args) {
16. blockingqueue<string> queue = new linkedblockingqueue<string> (2);
18. //blockingqueue<string> queue = new linkedblockingqueue<string> ();
20. //Not set, linkedblockingqueue default size is Integer.max_value
24. //blockingqueue<string> queue = new arrayblockingqueue<string> (2);
28. Consumer Consumer = new Consumer (queue);
30. Producer Producer = new Producer (queue);
32. for (int i = 0; i < 5; i++) {
34. New Thread (producer, "producer" + (i + 1)). Start ();
38. New Thread (Consumer, "consumer" + (i + 1)). Start ();
40. }
42. }
44. }

Import Java.util.concurrent.arrayblockingqueue;import Java.util.concurrent.blockingqueue;import Java.util.concurrent.linkedblockingqueue;public class Test3 {public static void main (string[] args) {blockingqueue< string> queue = new linkedblockingqueue<string> (2);//blockingqueue<string> queue = new Linkedblockingqueue<string> ();//If not set, linkedblockingqueue default size is integer.max_value//blockingqueue<string > queue = new arrayblockingqueue<string> (2); Consumer Consumer = new Consumer (queue); Producer Producer = new Producer (queue), for (int i = 0; i < 5; i++) {New Thread (Producer, "Producer" + (i + 1)). Start () ; New Thread (Consumer, "consumer" + (i + 1)). Start ();}}

Printing results:

Text Code

1. i have made a product:producer1  
2. i have made a& nbsp;product:producer2  
3. a product,  production line:producer1  
4. A  product,  production line:producer2  
5. i have made a product:producer3   
6. a product,  production line:producer3  
7. i have made a  product:producer5  
8. i have made a product:producer4  
9. a product,  production line:producer5  
10. a product,  production line:producer4  

I have made a product:producer1i has made a PRODUCT:PRODUCER2A product, production line: Producer1a product, production line: Producer2i has mad e a PRODUCT:PRODUCER3A product, production line: Producer3i has made a product:producer5i has made a PRODUCT:PRODUCER4A product, production line Process: producer5a product, production line: Producer4

Since the size of the queue is limited to 2, up to two products are added to the queue, and the order in which consumers take the product is in order of production, The reason is that both linkedblockingqueue and arrayblockingqueue are accessing elements in FIFO order.

Using Java's blockingqueue to implement producer-consumer