Introduction to the use of countdownlatch and cyclicbarrier for inter thread control

One 、CountDownLatch Introduce

        CountDownLatch class （ Count by subtraction ）; Is a thread synchronization helper class and CyclicBarrier class （ Counting by addition ） The function is similar to , Allow one or more threads to wait , Until a set of operations performed in other threads is complete .

Two 、CountDownLatch Two application scenarios ：

        Scene one ： All threads are waiting for the start signal startSignal.await(), The main flow sends a start signal to inform , Both implementation startSignal.countDown() After the method , All threads begin to execute ; Each thread sends a completion signal after execution , Both implementation doneSignal.countDown() Method ; When all threads are executed , The main process can continue to execute .   

package ThreadStudy;

import java.util.concurrent.CountDownLatch;

public class Driver1 {
	
	public static void main(String[] args) throws InterruptedException {
		int N = 5;
		CountDownLatch startSignal = new CountDownLatch(1);
		CountDownLatch doneSignal = new CountDownLatch(N);
		for (int i = 0; i < N; i++) {
			new Thread(new Work1(startSignal, doneSignal)).start();
		}
		// At this point, all threads are in a waiting state 
		System.out.println("doSomethingElse()");
		// Let all threads execute 
		startSignal.countDown();
		// Wait for all threads to finish executing 
		doneSignal.await();
		System.out.println("doSomethingElse()");
		
	}
}

class Work1 implements Runnable {
	
	private final CountDownLatch startSignal;
	private final CountDownLatch doneSignal;
	
	public Work1(CountDownLatch startSignal,CountDownLatch doneSignal) {
		this.startSignal=startSignal;
		this.doneSignal= doneSignal;
	}
	
	@Override
	public void run() {
		try {
			startSignal.await();
			doWork();
			doneSignal.countDown();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	void doWork() {
		System.out.println("doWork()");
	}
}

        Scene two ： Divide a big problem into N Parts of , Each part corresponds to a thread, which is put into the thread pool to execute , When the execution of each thread is completed, a completion signal is sent , Both call doneSignal.countDown() Method ; When all threads are executed , The main process can continue to execute .

package ThreadStudy;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Driver2 {
	public static void main(String[] args) throws Exception {
		int N = 5;
		CountDownLatch doneSignal = new CountDownLatch(N);
		// Define thread pool 
		ExecutorService exec = Executors.newSingleThreadExecutor();
		for (int i = 0; i < N; i++) {
			exec.execute(new Work2(doneSignal, i));
		}
		// Wait for all threads to complete 
		doneSignal.await();
		System.out.println("doSomethingElse()");
		// Close thread pool 
		exec.shutdown();
	}
}

class Work2 implements Runnable {
	private CountDownLatch doneSignal;
	private int i;

	public Work2(CountDownLatch doneSignal, int i) {
		this.doneSignal = doneSignal;
		this.i = i;
	}

	@Override
	public void run() {
		doWork(i);
		doneSignal.countDown();
	}

	void doWork(int i) {
		System.out.println("doWork():" + i);
	}
}

3、 ... and 、CountDownLatch And CyclicBarrier contrast

Four 、CountDownLatch Class

package ThreadStudy;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Csdn {
	public static void main(String[] args) throws Exception {
		int countLatch = 3;
		//  Create a specified number of latches 
		CountDownLatch countDownLatch = new CountDownLatch(countLatch);
		System.out.println("toString Method 0：" + countDownLatch.toString());
		for (int i = 0; i < countLatch; i++) {
			new Thread(new Runnable() {

				@Override
				public void run() {
					try {
						//  Reduce the number of latches by one 
						Thread.sleep(3000);
						countDownLatch.countDown();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

				}
			}).start();
		}
		//  Get the number of latches 
		long n = countDownLatch.getCount();
		System.out.println(" Number of latches ：" + n);
		//  Specify the timeout for waiting 
		countDownLatch.await(1, TimeUnit.SECONDS);
		System.out.println(" After the timeout, the program continues to execute ");
		//  The current thread is waiting , Until the number of latches is 0, The program goes down 
		countDownLatch.await();
		System.out.println("toString Method 1：" + countDownLatch.toString());

	}
}

5、 ... and 、CyclicBarrier Class

package ThreadStudy;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

public class CyclicBarrierTest {
	public static void main(String[] args) {

		//  Construction method 1 ： Create a thread for 3 Circulation barrier of ,3 After all threads reach the obstacle point , Just go down ！
		 CyclicBarrier cb1 = new CyclicBarrier(3);

		//  Construction method 2 ： Create a new CyclicBarrier, When the last thread passes through the obstacle point, it will trigger the thread execution here 
		CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {

			@Override
			public void run() {
				System.out.println("== The thread that triggers execution after passing the obstacle point ==");
			}
		});
		//  Returns the number of people currently waiting at the barrier . This method is mainly used for debugging and asserting 
		int a = cb.getNumberWaiting();
		System.out.println(" Returns the number of people currently waiting at the barrier " + a);

		//  Return the number of people needed to cross the barrier 
		int b = cb.getParties();
		System.out.println(" Return the number of people needed to cross the barrier :" + b);

		//  Check whether the barrier is in an interrupted state ：
		boolean bo = cb.isBroken();
		System.out.println(" Check whether the barrier is in an interrupted state ：" + bo);

		for (int i = 0; i < 4; i++) {

			new Thread(new Runnable() {

				@Override
				public void run() {

					System.out.println(" Threads ：" + Thread.currentThread().getName() + " Enter the obstacle point and wait ");
					try {
						//  wait for , Until all parties have invoked... On this barrier await.
						int d = cb.await();
						System.out.println("d:" + d);

						//  wait for , Until all parties have invoked... On this barrier await, Or the specified waiting time has passed 
						int c = cb.await(1, TimeUnit.SECONDS);
						System.out.println("c:" + c);
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println(" Through obstacles ");

				}
			}).start();
		}
		//  Reset operation , At this point, the thread waiting at the obstacle point will throw BrokenBarrierException abnormal 
		cb.reset();
	}
}