This article brings you an introduction to the usage of the three auxiliary classes CountDownLatch, CyclicBarrier and Semaphore in Java. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.
In Java 1.5, some very useful auxiliary classes are provided to help us with concurrent programming, such as CountDownLatch, CyclicBarrier and Semaphore. Today we will learn the usage of these three auxiliary classes.
1. CountDownLatch usage
The CountDownLatch class is located under the java.util.concurrent package, which can be used to implement counter-like functions. For example, there is a task A that has to wait for the other four tasks to complete before it can be executed. At this time, you can use CountDownLatch to implement this function.
The CountDownLatch class only provides one constructor:
public CountDownLatch(int count) { }; //参数count为计数值
Then the following three methods are the most important methods in the CountDownLatch class:
public void await() throws InterruptedException { }; //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行 public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行 public void countDown() { }; //将count值减1
Let’s look at an example below. It’s clear how to use CountDownLatch:
public class Test { public static void main(String[] args) { final CountDownLatch latch = new CountDownLatch(2); new Thread(){ public void run() { try { System.out.println("子线程"+Thread.currentThread().getName()+"正在执行"); Thread.sleep(3000); System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕"); latch.countDown(); } catch (InterruptedException e) { e.printStackTrace(); } }; }.start(); new Thread(){ public void run() { try { System.out.println("子线程"+Thread.currentThread().getName()+"正在执行"); Thread.sleep(3000); System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕"); latch.countDown(); } catch (InterruptedException e) { e.printStackTrace(); } }; }.start(); try { System.out.println("等待2个子线程执行完毕..."); latch.await(); System.out.println("2个子线程已经执行完毕"); System.out.println("继续执行主线程"); } catch (InterruptedException e) { e.printStackTrace(); } } }
Execution result:
线程Thread-0正在执行 线程Thread-1正在执行 等待2个子线程执行完毕... 线程Thread-0执行完毕 线程Thread-1执行完毕 2个子线程已经执行完毕 继续执行主线程
2. CyclicBarrier usage
literally means loop barrier, through which you can Implement a group of threads to wait for a certain state before executing them all at the same time. It is called loopback because CyclicBarrier can be reused after all waiting threads are released. Let's call this state barrier for the time being. When the await() method is called, the thread is in barrier.
The CyclicBarrier class is located under the java.util.concurrent package. CyclicBarrier provides two constructors:
public CyclicBarrier(int parties, Runnable barrierAction) { } public CyclicBarrier(int parties) { }
The parameter parties refers to how many threads or tasks are allowed to wait for the barrier state; the parameter barrierAction is when these What will be executed when all threads reach the barrier state.
Then the most important method in CyclicBarrier is the await method, which has 2 overloaded versions:
public int await() throws InterruptedException, BrokenBarrierException { }; public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
The first version is more commonly used and is used to suspend the current thread until all threads Reach the barrier state and then execute subsequent tasks at the same time;
The second version is to let these threads wait for a certain period of time. If there are still threads that have not reached the barrier state, directly let the threads that have reached the barrier perform subsequent tasks.
Let’s take a few examples to understand:
If there are several threads that have to write data operations, and only after all threads have completed the data writing operations, these threads can continue to do the following For things like Wait for other threads to complete the write operation.
When all thread writing operations are completed, all threads will continue to perform subsequent operations.
If you want to perform additional operations after all threads have finished writing operations, you can provide Runnable parameters for CyclicBarrier:
public class Test { public static void main(String[] args) { int N = 4; CyclicBarrier barrier = new CyclicBarrier(N); for(int i=0;i
Running results:
线程Thread-0正在写入数据... 线程Thread-3正在写入数据... 线程Thread-2正在写入数据... 线程Thread-1正在写入数据... 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-0写入数据完毕，等待其他线程写入完毕 线程Thread-3写入数据完毕，等待其他线程写入完毕 线程Thread-1写入数据完毕，等待其他线程写入完毕 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务...
From the results, you can It can be seen that when all four threads reach the barrier state, one thread will be selected from the four threads to execute Runnable.
Let’s take a look at the effect of specifying time for await:
public class Test { public static void main(String[] args) { int N = 4; CyclicBarrier barrier = new CyclicBarrier(N,new Runnable() { @Override public void run() { System.out.println("当前线程"+Thread.currentThread().getName()); } }); for(int i=0;i
Execution results:
线程Thread-0正在写入数据... 线程Thread-1正在写入数据... 线程Thread-2正在写入数据... 线程Thread-3正在写入数据... 线程Thread-0写入数据完毕，等待其他线程写入完毕 线程Thread-1写入数据完毕，等待其他线程写入完毕 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-3写入数据完毕，等待其他线程写入完毕 当前线程Thread-3 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务...
The above code deliberately starts the last thread in the for loop of the main method. Delay, because after the first three threads have reached the barrier, after waiting for the specified time and finding that the fourth thread has not reached the barrier, an exception is thrown and the subsequent tasks continue to be executed.
In addition, CyclicBarrier can be reused. See the following example:
public class Test { public static void main(String[] args) { int N = 4; CyclicBarrier barrier = new CyclicBarrier(N); for(int i=0;i
Execution results:
线程Thread-0正在写入数据... 线程Thread-2正在写入数据... 线程Thread-1正在写入数据... 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-0写入数据完毕，等待其他线程写入完毕 线程Thread-1写入数据完毕，等待其他线程写入完毕 线程Thread-3正在写入数据... java.util.concurrent.TimeoutException Thread-1所有线程写入完毕，继续处理其他任务... Thread-0所有线程写入完毕，继续处理其他任务... at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) Thread-2所有线程写入完毕，继续处理其他任务... java.util.concurrent.BrokenBarrierException 线程Thread-3写入数据完毕，等待其他线程写入完毕 at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) Thread-3所有线程写入完毕，继续处理其他任务...
It can be seen from the execution results that the first four threads crossed the barrier. After the state is reached, it can be used for a new round of use. CountDownLatch cannot be reused.
3. Semaphore usage
Semaphore is translated literally as semaphore. Semaphore can control the number of threads accessed at the same time and obtain a permission through acquire(). If If not, wait, and release() releases a permission.The Semaphore class is located under the java.util.concurrent package. It provides two constructors:
public class Test { public static void main(String[] args) { int N = 4; CyclicBarrier barrier = new CyclicBarrier(N); for(int i=0;i
Let’s talk about some of the more important methods in the Semaphore class. The first is acquire() , release() method:
线程Thread-0正在写入数据... 线程Thread-1正在写入数据... 线程Thread-3正在写入数据... 线程Thread-2正在写入数据... 线程Thread-1写入数据完毕，等待其他线程写入完毕 线程Thread-3写入数据完毕，等待其他线程写入完毕 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-0写入数据完毕，等待其他线程写入完毕 Thread-0所有线程写入完毕，继续处理其他任务... Thread-3所有线程写入完毕，继续处理其他任务... Thread-1所有线程写入完毕，继续处理其他任务... Thread-2所有线程写入完毕，继续处理其他任务... CyclicBarrier重用 线程Thread-4正在写入数据... 线程Thread-5正在写入数据... 线程Thread-6正在写入数据... 线程Thread-7正在写入数据... 线程Thread-7写入数据完毕，等待其他线程写入完毕 线程Thread-5写入数据完毕，等待其他线程写入完毕 线程Thread-6写入数据完毕，等待其他线程写入完毕 线程Thread-4写入数据完毕，等待其他线程写入完毕 Thread-4所有线程写入完毕，继续处理其他任务... Thread-5所有线程写入完毕，继续处理其他任务... Thread-6所有线程写入完毕，继续处理其他任务... Thread-7所有线程写入完毕，继续处理其他任务...
acquire() is used to obtain a permission. If no permission can be obtained, it will wait until the permission is obtained.
release() is used to release the license. Note that permission must be obtained before it can be released.
These four methods will be blocked. If you want to get the execution result immediately, you can use the following methods:
public Semaphore(int permits) { //参数permits表示许可数目，即同时可以允许多少线程进行访问 sync = new NonfairSync(permits); } public Semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可 sync = (fair)? new FairSync(permits) : new NonfairSync(permits); }
In addition, you can also get the number of available permissions through the availablePermits() method.
Let’s take a look at the specific use of Semaphore through an example:
If a factory has 5 machines but 8 workers, one machine can only be used by one worker at the same time. After using it, other workers can continue to use it. Then we can achieve it through Semaphore:
public void acquire() throws InterruptedException { } //获取一个许可 public void acquire(int permits) throws InterruptedException { } //获取permits个许可 public void release() { } //释放一个许可 public void release(int permits) { } //释放permits个许可
Execution result:
public boolean tryAcquire() { }; //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
The following is a summary of the three auxiliary classes mentioned above:
1) CountDownLatch and Both CyclicBarrier can realize waiting between threads, but their focus is different:
CountDownLatch is generally used for a thread A to wait for several other threads to complete their tasks before executing it;
And CyclicBarrier is generally used for a group of threads to wait for each other to reach a certain state, and then this group The threads are executed simultaneously;
In addition, CountDownLatch cannot be reused, but CyclicBarrier can be reused.
2) Semaphore is actually somewhat similar to a lock. It is generally used to control access to a certain group of resources.
The above is the detailed content of Introduction to the usage of the three auxiliary classes CountDownLatch, CyclicBarrier and Semaphore in Java. For more information, please follow other related articles on the PHP Chinese website!