[Reprint] Java Multithreaded learning-java.util.concurrent detailed (a) latch/barrier

Reprinted from http://janeky.iteye.com/blog/769965

JAVA1.5 provides a highly efficient and practical multithreaded package: Java.util.concurrent, which provides a number of advanced tools to help developers write efficient, maintainable, and well-structured Java multithreaded applications. From this blog, I will work with you to learn these new Java multithreaded components

1.CountDownLatch
Let's start by learning more about this class in the JDK1.5 API:
"A synchronous helper class that allows one or more threads to wait until a set of operations that are being performed in another thread is completed. Initializes the countdownlatch with the given count. Because the countdown () method is called, the await method is blocked until the current count reaches 0. After that, all the waiting threads are freed, and all subsequent calls to await are returned immediately. This behavior occurs only once-the count cannot be reset. If you need to reset the count, consider using Cyclicbarrier. ”

This means that countdownlatch can be used to manage a set of related thread executions by calling the Countdownlatch await method (which is blocked) in the main thread, allowing each thread to invoke the Countdown method. When all the threads have just finished countdown, await also returns smoothly, no longer blocked. This is especially true in situations where a task is divided into threads that are executed until all threads are executed and then summarized.

Let me give you a very simple example. Let's say we're going to print 1-100 and then output "OK". 1-100 printing order does not require unification, just ensure that "OK" is in the last appearance.

Solution: We define a countdownlatch and then open 10 threads to print (n-1) *10+1 to (n-1) *10+10 respectively. The await method is called in the main thread to wait for all threads to finish executing, and the countdown method is called after each thread finishes executing. Finally, await return and print "OK".

The specific code is as follows (this code references the JDK sample code):
Java code

2. Import Java.util.concurrent.CountDownLatch;
4. /**
6. * Example: Examples of use of Countdownlatch
8. * Mail: [email protected]
10. * @author Janeky
12. */
14. Public class Testcountdownlatch {
16. private static final int N = 10;
20. public static void Main (string[] args) throws interruptedexception {
22. Countdownlatch donesignal = new Countdownlatch (N);
24. Countdownlatch startsignal = new Countdownlatch (1); Start signal execution
28. For (int i = 1; I <= N; i++) {
30. New Thread (new Worker (i, donesignal, startsignal)). Start (); Thread started.
32. }
34. SYSTEM.OUT.PRINTLN ("begin------------");
36. Startsignal.countdown (); //Start execution
38. Donesignal.await (); //wait for all threads to finish executing
40. System.out.println ("OK");
44. }
48. static class Worker implements Runnable {
50. Private final Countdownlatch donesignal;
52. Private final Countdownlatch startsignal;
54. private int beginindex;
58. Worker (int beginindex, Countdownlatch donesignal,
60. Countdownlatch startsignal) {
62. this.startsignal = startsignal;
64. this.beginindex = beginindex;
66. this.donesignal = donesignal;
68. }
72. public Void Run () {
74. try {
76. Startsignal.await (); //Wait to start the release of the signal
78. Beginindex = (Beginindex- 1) * ten + 1;
80. For (int i = beginindex; I <= beginindex + i++) {
82. System.out.println (i);
84. }
86. } catch (Interruptedexception e) {
88. E.printstacktrace ();
90. } finally {
92. Donesignal.countdown ();
94. }
96. }
98. }
100. }

Summary: Coundownlatch is useful for managing a set of related threads. Two usage scenarios are depicted visually in the example code above. The first is a calculator of 1, which represents two states, switches. The second is that the counter is N, which means waiting for n operations to complete. We can use this component to manage the execution of a set of independent threads in the future when we are writing multi-threaded programming.

2.CyclicBarrier
Let's start by learning more about this class in the JDK1.5 API:
"A synchronization helper class that allows a group of threads to wait on each other until a common barrier point (common barrier points) is reached. In programs that involve a set of fixed-size threads, these threads have to wait for each other, and cyclicbarrier is useful at this time. Because the barrier can be reused after releasing the waiting thread, it is called a cyclic barrier.
Cyclicbarrier supports an optional Runnable command that runs only once at each barrier point after the last thread in a set of threads arrives (but before releasing all threads). This barrier operation is useful if you update the shared state before continuing with all participating threads.

We talked about Cyclicbarrier when we were studying countdownlatch. What is the connection between the two? Refer to the description in [Jcip], "The key difference is and a barrier, all the threads must come together at a barrier point at the same Time in order to proceed. Latches is for waiting for events; Barriers is for waiting to other threads. Cyclicbarrier waits for all threads to complete together before performing an action. This is also possible with the Countdownlatch function. But countdownlatch more often waits for an event to happen. In Cyclicbarrier, all threads call the await method, waiting for the other threads to finish executing.

To give a very simple example, tonight our Buddies 4 go to happy. On each other's notice: Eight o'clock in the evening to XX bar in front of the assembly, see not scattered! There is a friend living near, early on. Some of the affairs are busy, just casing. No matter what, first-come can not act alone, can only wait for everyone

The code is as follows (refer to some tutorials on the web)
Java code

2. Import Java.util.Random;
4. Import java.util.concurrent.BrokenBarrierException;
6. Import Java.util.concurrent.CyclicBarrier;
8. Import Java.util.concurrent.ExecutorService;
10. Import java.util.concurrent.Executors;
14. Public class Testcyclicbarrier {
18. public static void Main (string[] args) {
22. Executorservice exec = Executors.newcachedthreadpool ();
24. final random random=new Random ();
28. final Cyclicbarrier barrier=new Cyclicbarrier (4,new Runnable () {
30. @Override
32. public Void Run () {
34. System.out.println ("Everyone is here, start happy");
36. }});
40. For (int i=0;i<4;i++) {
42. Exec.execute (new Runnable () {
44. @Override
46. public Void Run () {
48. try {
50. Thread.Sleep (Random.nextint (1000));
52. } catch (Interruptedexception e) {
54. E.printstacktrace ();
56. }
58. System.out.println (Thread.CurrentThread (). GetName () +"Come, Other Buddies");
60. try {
62. Barrier.await (); //wait for other buddies
64. } catch (Interruptedexception e) {
66. E.printstacktrace ();
68. } catch (Brokenbarrierexception e) {
70. E.printstacktrace ();
72. }
74. }});
76. }
78. Exec.shutdown ();
80. }
84. }

About the await method pay special attention to the possibility that it may be interrupted for some reason during the blocking process.

Summary: Cyclicbarrier is a fence that waits for all threads to arrive before performing related operations. Barrier can be reused after releasing the wait thread.

[Reprint] Java Multithreaded learning-java.util.concurrent detailed (a) latch/barrier