7.CountDownLatch&Semaphore的应用

7.CountDownLatch&Semaphore的应用

1.0 Semaphore是什么？

Semaphore 是信号量的意思，它的作用是控制访问特定资源的线程数目，底层依赖 AQS 的状态 State，是在生产当中比较常用的一个工具类。

有“控制访问特定的资源的线程数目”，可以知道当一个并发量很大的服务访问一个并发量小的服务时，可以用Semaphore 做限流功能，她的一个经典场景就是服务限流(Hystrix 里限流就是基于信号量方式) 。

1.1 Semaphore使用

1.1.1构造方法

 public Semaphore(int permits)
 public Semaphore(int permits, boolean fair)

• permits表示许可线程的数量
• fair表示公平性，如果这个设为true的话，下次执行的线程会是等待最久的线程

1.1.2重要方法

public void acquire(() throws InterruptedException
public void release() 
tryAcquire (int args,long timeout, TimeUnit unit)

• acquire()表示阻塞并获取许可
• release()表示释放许可
• tryAcquire 当前线程在限定的时间内尝试去获取 1 个许可证，得不到不等待。

使用例子如下：

import java.util.Date;
import java.util.concurrent.Semaphore;  
  
public class SemaphoreRunner {  
    public static void main(String[] args) {  
        Semaphore semaphore = new Semaphore(2);  
        for (int i = 0; i < 10; i++) {  
            new Thread(new Task(semaphore, "任务:" + i)).start();  
        }  
    }
    static class Task extends Thread {  
        Semaphore semaphore;  
  
        public Task(Semaphore semaphore, String tname) {  
            this.semaphore = semaphore;  
            this.setName(tname);  
        }
        @Override  
        public void run() {  
            try {  
                //获得公共资源
                semaphore.acquire();  
                System.out.println(this.getName() + "获得许可证 at time:" + new Date());  
                Thread.sleep(3000);  
                //释放公共资源
                semaphore.release();
                System.out.println(this.getName() + "释放许可证 at time:" + new Date());
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
  
        }  
    }  
}

总结：一次只有两个线程执行acquire，只有线程进行release方法后才会有别的线程执行acquire。

2.0 CountDownLatch使用场景及例子

2.1 CountDownLatch 是什么？

​ CountDownLatch 这个类能够使一个线程等待其他线程完成各自的工作后在执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

2.2 CountDownLatch 工作流程

​ CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成自己的任务后，计数器的值就会减少1。当计数器的值到达0时，它标识所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

2.3 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 CountDownlatchRunner {  
    public static void main(String[] args) throws InterruptedException {  
        CountDownLatch countDownLatch = new CountDownLatch(5);  
        for(int i=0;i<5;i++){  
            new Thread(new ReadNum(i,countDownLatch)).start();  
        }  
        // 等待所有线程结束
        countDownLatch.await();  
        System.out.println("线程执行结束。。。。");  
    }  
  
    static class ReadNum  implements Runnable{  
        private int id;  
        private CountDownLatch latch;  
        public ReadNum(int id,CountDownLatch latch){  
            this.id = id;  
            this.latch = latch;  
        }  
        @Override  
        public void run() {  
            synchronized (this){  
                System.out.println("id:"+id);  
                latch.countDown();  
                System.out.println("线程组任务"+id+"结束，其他任务继续");  
            }  
        }  
    }  
}

3.0 CycliBarrier 的应用

​ 栅栏屏障，让一组线程到达一个屏障(又称同步点)时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

​ CycliBarrier默认构造方法CycliBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CycliBarrier已经到达屏障，然后当前线程阻塞。

// 指定了N个线程互相等待
public CyclicBarrier(int parties) { }
// 指定N个线程在任务 barrierAction  处互相等待
public CyclicBarrier(int parties, Runnable barrierAction) { } 
public int await() throws InterruptedException, BrokenBarrierException {
        //挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
}
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException {
//让这些线程等待至一定的时间，如果还有线程没有到达barrier状态
//就直接让到达barrier的线程执行后续任务
}

3.1应用场景

​ 可以用于多线程计算数据，最后合并计算结果的场景。例如，用一个Excel保存用户的所有银行流水，每个sheet保存一个账户一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，得到每个sheet的日均银行流水，最后再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
	public static void main(String[] args) throws InterruptedException {
		CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
			@Override
			public void run() {
				System.out.println("线程组执行结束");
			}
		});
		for (int i = 0; i < 5; i++) {
			new Thread(new ReadNum(i,cyclicBarrier)).start();
		}
		//CyclicBarrier 可以重复利用，
		// 这个是CountDownLatch做不到的
//        for (int i = 11; i < 16; i++) {
//            new Thread(new readNum(i,cyclicBarrier)).start();
//        }
	}
	static class ReadNum  implements Runnable{
		private int id;
		private CyclicBarrier cyc;
		public ReadNum(int id,CyclicBarrier cyc){
			this.id = id;
			this.cyc = cyc;
		}
		@Override
		public void run() {
			synchronized (this){
				System.out.println("id:"+id);
				try {
				// 线程等待，直到5各线程都运行到这里再一起执行
					cyc.await();
					System.out.println("线程组任务" + id + "结束，其他任务继续");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
}

4.总结：

BlockingQueue、Semaphore 和CountDownLatch 线程之间通信的桥梁和工具 。Semaphore可以应用到服务调用之间的限流；CountDownLatch和CyclicBarrier区别如下：CountDownLatch是以减数的方式而CyclicBarrier是以加数的方式；CountDownLatch强调的是一个等待其他多个线程而CyclicBarrier是一组线程相互等待；CountDownLatch不可重复利用而CyclicBarrier可重复利用。