CountDownLatch、CyclicBarrier和 Semaphore的用法

最新推荐文章于 2025-06-25 09:47:32 发布

IUNIQUE

最新推荐文章于 2025-06-25 09:47:32 发布

阅读量285

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java web后端并发编程文章标签：并发编程 java CountDownLatch CyclicBarrier Semaphore

本文链接：https://blog.youkuaiyun.com/IUNIQUE/article/details/88945269

Java 同时被 3 个专栏收录

32 篇文章

订阅专栏

web后端

25 篇文章

订阅专栏

并发编程

12 篇文章

订阅专栏

本文介绍了并发编程中常用的三种工具：CountDownLatch、CyclicBarrier和Semaphore。CountDownLatch用于一个线程等待多个线程完成任务；CyclicBarrier用于一组线程互相等待至某个状态后同时执行；Semaphore用于控制对某组资源的访问权限。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

并发编程：CountDownLatch、CyclicBarrier和 Semaphore的用法

可以利用它实现类似计数器的功能。比如有一个任务A，它要等待其他若干个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了；也可以用来控制初始化操作，某个任务执行之前，必须初始化成功之后，才能进行操作，否则将一直阻塞。
类方法介绍：

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

例子程序范例：

public class CountDownLatchTest{
     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()+"执行完毕");
                    //一个任务执行完成，countDown一次
                    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()+"执行完毕");
                      //一个任务执行完成，countDown一次
                     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();
        }
     }
}

CyclicBarrier用法

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了；换句话说，就是控制多个任务在某种条件下，同时运行。
类方法介绍：
参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

例子程序范例：

public class CyClicBarrierTest {
    public static void main(String[] args) {
        int N = 4;
        //指定等待的线程个数
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++)
            new Task(barrier).start();
    }
    //任务线程
    static class Task extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Task(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在进行准备操作...");
            try {
                Thread.sleep(5000);  
                System.out.println("线程"+Thread.currentThread().getName()+"准备完毕，等待其他任务准备完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程准备完毕，任务继续处理其他操作...");
        }
    }
}

如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数：

public class CyClicBarrierTest {
    public static void main(String[] args) {
        int N = 4;
        //指定等待的线程个数
        CyclicBarrier barrier  = new CyclicBarrier(N，new Runnable({
			@Override
			public void run(){
				System.out.println("所有任务已经准备好了，可以继续执行其他操作了");
			}
		}));
        for(int i=0;i<N;i++)
            new Task(barrier).start();
    }
    //任务线程
    static class Task extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Task(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在进行准备操作...");
            try {
                Thread.sleep(5000);  
                System.out.println("线程"+Thread.currentThread().getName()+"准备完毕，等待其他任务准备完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程准备完毕，任务继续处理其他操作...");
        }
    }
}

Semaphore用法

Semaphore翻译成字面意思为信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
类方法介绍：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

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

例子程序范例：

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现：
public class SemaphoreTest {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
 
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }
 
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

下面对上面说的三个辅助类进行一个总结：
1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：
CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；
而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；
另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。
2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。