CountDownLatch、 CyclicBarrier 和 semaphore的介绍
countDownLatch:
CountDownLatch类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。
CyclicBarrier类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。
Semaphore类提供了一个计数信号量。通过Semaphore类,可以控制某个资源可被同时访问的个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。Semaphore的构造函数中带有一个fairness的参数,用于设置是否“公平”。当fairness为true时,Semaphore保证各线程以后进先出(FIFO)的方式获得信号量。如果fairness为false,则不保证这种顺序
CountDownLatch、 CyclicBarrier 和 semaphore的使用·
CountDownLatch的例子
public class CountDownTest {
public static void main(String[] args) {
//5代表线程数量
final CountDownLatch countDownLatch = new CountDownLatch(5);
System.out.println("多线程准备阶段!");
for (int i = 0; i < 5; i++){
new Thread(){
@Override
public void run() {
System.out.println("线程名称:>>>" + Thread.currentThread().getName());
try {
Thread.sleep(100);
} catch (Exception e){
e.printStackTrace();
}
//计算线程完成情况
countDownLatch.countDown();
}
}.start();
}
try {
//等待所有线程完成再执行此语句
countDownLatch.await();
}catch (Exception e){
e.printStackTrace();
}
System.out.println("多线程完成阶段:SUCCESS!");
}
}
CyclicBarrier的例子
public class CyclicBarrierTest1 {
public static void main(String[] args) {
final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
new Thread(){
@Override
public void run() {
try {
Thread.sleep(5000);
System.out.println("Thread1 到达指定集合地点!");
cyclicBarrier.await();
Thread.sleep(1000);
System.out.println("Thread1 等待其他成员到达指定到底,我来看看是否还缺人...");
}catch (Exception e){
e.printStackTrace();
}
}
}.start();
new Thread(){
@Override
public void run() {
try {
Thread.sleep(10000);
System.out.println("Thread2 到达指定集合地点!");
cyclicBarrier.await();
Thread.sleep(2000);
System.out.println("Thread2 等待其他成员到达指定到底,我来看看是否还缺人...");
}catch (Exception e){
e.printStackTrace();
}
}
}.start();
try {
cyclicBarrier.await();
Thread.sleep(3000);
System.out.println("所有成员都已经到达指定集合地点,开始出发去玩!");
}catch (Exception e){
e.printStackTrace();
}
}
}
Semaphore的例子
package com.lte.threadtest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
public static void main(String[] args) {
ExecutorService service = Executors. newCachedThreadPool();
final Semaphore sp = new Semaphore(3);
for (int i = 0; i < 10; i++) {
Runnable runnable = new Runnable() {
public void run() {
try {
sp.acquire();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
System. out.println("线程" + Thread.currentThread().getName() + "进入,当前已有" + (3 - sp.availablePermits()) + "个并发" );
try {
Thread. sleep((long) (Math. random() * 10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System. out.println("线程" + Thread.currentThread().getName() + "即将离开");
sp.release();
// 下面代码有时候执行不准确,因为其没有和上面的代码合成原子单元
// availablePermits()指的是当前信号灯库中有多少个可以被使用
System. out.println("线程" + Thread.currentThread().getName() + "已离开,当前已有" + (3 - sp.availablePermits()) + "个并发" );
}
};
service.execute(runnable);
}
}
}