Java Multi-thread ~ ~ ~ Using exchanger to exchange data between threads [this combination of multi-threaded parallelism will solve a lot of problems]

http://blog.csdn.net/a352193394/article/details/39503857

Java Multi-thread ~ ~ ~ Using exchanger to exchange data between threads [this combination of multi-threaded parallel will solve a lot of problems] specifically see http://www.cnblogs.com/donaldlee2008/p/5290169.html java Thread pool Parallel Execution http://www.cnblogs.com/donaldlee2008/p/5290169.htmlJava Multi-thread ~ ~ ~ Exchange data between threads using exchanger2014-09-23 20:48 1205 people read comments (0) favorite reports Classification:Multithreading (+)

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

In multi-threading, exchanging data between two threads is very common, and we can use a common data structure, and Java also provides a good

Class for us to use, that is the exchanger class, this class can help us to synchronize data structure between two threads, and then we will take this class to real

Now a producer consumer model, it seems that the model has been written rotten.

[Java]View PlainCopyprint?

2. Package com.bird.concursey.charpet5;
6. Import java.util.List;
8. Import Java.util.concurrent.Exchanger;
12. Public class Producer implements Runnable {
14. //this'll is the data structure that the producer would interchange with the consumer.
16. private list<string> buffer;
20. private exchanger<list<string>> Exchanger;
24. Public Producer (list<string> buffer, exchanger<list<string>> Exchanger) {
26. super ();
28. this.buffer = buffer;
30. This.exchanger = exchanger;
32. }
36. @Override
38. public Void Run () {
40. int cycle = 1;
42. For (int i = 0; i < i++) {
44. System.out.printf ("Producer:cycle%d\n", Cycle);
46. For (int j=0; j<; j + +) {
48. String message="Event" + ((i*) +j);
50. System.out.printf ("Producer:%s\n", message);
52. Buffer.add (message);
54. }
56. try {
58. Buffer = exchanger.exchange (buffer);
60. } catch (Interruptedexception e) {
62. //TODO auto-generated catch block
64. E.printstacktrace ();
66. }
68. System.out.println ("Producer:" +buffer.size ());
70. cycle++;
72. }
74. }
78. }

[Java]View PlainCopyprint?

2. Package com.bird.concursey.charpet5;
6. Import java.util.ArrayList;
8. Import java.util.List;
10. Import Java.util.concurrent.Exchanger;
14. Public class Consumer implements Runnable {
18. private list<string> buffer;
22. private exchanger<list<string>> exchange;
26. Public Consumer (list<string> buffer, exchanger<list<string>> Exchange) {
28. super ();
30. this.buffer = buffer;
32. this.exchange = Exchange;
34. }
40. @Override
42. public Void Run () {
44. int cycle = 1;
46. For (int i = 0; i < i++) {
48. System.out.printf ("Consumer:cycle%d\n", Cycle);
50. try {
52. Buffer = exchange.exchange (buffer);
54. } catch (Interruptedexception e) {
56. E.printstacktrace ();
58. }
60. System.out.println ("Consumer:" +buffer.size ());
62. For (int j=0; j<; j + +) {
64. String Message=buffer.get (0);
66. System.out.println ("Consumer:" +message);
68. Buffer.remove (0);
70. }
72. cycle++;
74. }
76. }
80. public static void Main (string[] args) {
82. list<string> buffer1 = new arraylist<string> ();
84. list<string> buffer2 = new arraylist<string> ();
88. Exchanger<list<string>> Exchange = new exchanger<list<string>> ();
92. Producer Producer = new Producer (Buffer1, Exchange);
94. Consumer Consumer = new Consumer (buffer2, Exchange);
98. Thread threadproducer=new Thread (producer);
100. Thread threadconsumer=new Thread (consumer);
104. Threadproducer.start ();
106. Threadconsumer.start ();
108. }
112. }

[HTML]View PlainCopyprint?

1. The consumer begins with a empty buffer and calls Exchanger to synchronize with the
2. Producer. It needs data to consume. The producer begins its execution with an empty buffer.
3. It creates strings, stores it in the buffer, and uses the exchanger-synchronize with
4. The consumer.

[HTML]View PlainCopyprint?

1. At this point, both threads (producer and consumer) is in Exchanger and it changes the
2. Data structures, if the consumer returns from the Exchange () method, it would have a
3. Buffer with ten strings. When the producer returns from the Exchange () method, it would have
4. An empty buffer to fill again. This operation is to be repeated ten times.

[HTML]View PlainCopy print?

1. If You execute the example, you'll see how producer and consumer do their jobs
2. Concurrently and how the other objects interchange their buffers in every step. As it occurs with
3. Other synchronization utilities, the first thread that calls the Exchange () method is put to
4. Sleep until the other threads arrived.

Java Multi-thread ~ ~ ~ Using exchanger to exchange data between threads [this combination of multi-threaded parallelism will solve a lot of problems]