【JUC并发编程】CyclicBarrier、CountDownLatch、Semaphore的用法

小灰灰 2023-09-29 13:46 79阅读 0赞

#### 目录 ####

*  1. CountDownLatch
 *  2. CountDownLatch与Join的区别
 *  3. Semaphore概念
 *  4. CyclicBarrier
 *  5. 总结

--------------------

## 1. CountDownLatch ##

CountDownLatch是一种java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程中一组操作执行完成。 和join方法非常类似  
CountDownLatch底层是基于AQS实现的  
CountDownLatch countDownLatch=new CountDownLatch(2) AQS的state状态为2  
调用countDownLatch.countDown();方法的时候状态-1 当AQS状态state为0的情况下，则唤醒正在等待的线程。

final CountDownLatch latch = new CountDownLatch(2);
    	new Thread(){
        public void run() {
        
    		System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
     		Thread.sleep(3000);
    		System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
     		latch.countDown();
    	};}.start();
    	new Thread(){
         public void run() {
        
    		System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
    		 Thread.sleep(3000);
    		 System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
    		 latch.countDown();
    	};}.start();
    	System.out.println("等待 2 个子线程执行完毕...");
    	latch.await();
    	System.out.println("2 个子线程已经执行完毕");
    	System.out.println("继续执行主线程");
    }

## 2. CountDownLatch与Join的区别 ##

Join底层是基于wait方法实现，而CountDownLatch底层是基于AQS实现。

CountDownLatch底层原理分析：

1.  CountDownLatch底层是基于AQS实现；
2.  CountDownLatch通过构造函数设置AQS的状态值state
3.  await方法实现：

## 3. Semaphore概念 ##

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

1.  public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
2.  public void acquire(int permits):获取 permits 个许可
3.  public void release() \{ \} :释放许可。注意，在释放许可之前，必须先获获得许可。
4.  public void release(int permits) \{ \}:释放 permits 个许可

上面 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法

1.  public boolean tryAcquire():尝试获取一个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
2.  public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
3.  public boolean tryAcquire(int permits):尝试获取 permits 个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
4.  public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
5.  还可以通过 availablePermits()方法得到可用的许可数目。  
    例子：若一个工厂有 5 台机器，但是有 8 个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现：

nt 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();
    		}
    	}

## 4. CyclicBarrier ##

栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。

CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用

public class Test002 {
        
        public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        
            // new 同步屏障  设定值=2  需要有两个线程调用await方法程序才会继续向下执行
            CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
            new Thread(() -> {
        
                try {
        
                    System.out.println(Thread.currentThread().getName() + ",1");
                    cyclicBarrier.await();// 2-1=1 1>0
                    System.out.println(Thread.currentThread().getName() + ",2");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
        
                    e.printStackTrace();
                }
            }, "t1").start();
            try {
        
                Thread.sleep(3000);
            } catch (Exception e) {
        
    
            }
            new Thread(() -> {
        
                try {
        
                    System.out.println(Thread.currentThread().getName() + ",1");
                    cyclicBarrier.await();//1-1=0
                    System.out.println(Thread.currentThread().getName() + ",2");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
        
                    e.printStackTrace();
                }
            }, "t2").start();
        }
    }

## 5. 总结 ##

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