多线程限流及线程等待执行（ Semaphore， CountDownLatch）

Semaphore 使用及应用场

. Semaphore 是什么？
Semaphore 字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目，底层依
赖AQS的状态State，是在生产当中比较常用的一个工具类。
2. 怎么使用 Semaphore？
2.1 构造方法
1 public Semaphore(int permits) 2 public Semaphore(int permits, boolean fair)
permits 表示许可线程的数量
fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程

重要方法

1 public void acquire() throws InterruptedException
2 public void release()
3 tryAcquire（long timeout, TimeUnit unit）

acquire() 表示阻塞并获取许可
release() 表示释放许可

使用场景
资源访问，服务限流(Hystrix里限流就有基于信号量方式)
代码实现

1 public class SemaphoreRunner {
2  public static void main(String[] args) {
3  Semaphore semaphore = new Semaphore(2);
4  for (int i=0;i<5;i++){
5  new Thread(new Task(semaphore,"yangguo+"+i)).start();
6  }
7  }
8 
9  static class Task extends Thread{
10  Semaphore semaphore;
11 
12  public Task(Semaphore semaphore,String tname){
13  this.semaphore = semaphore;
14  this.setName(tname);
15  }
16 
17  public void run() {
18  try {
19  semaphore.acquire();
20  System.out.println(Thread.currentThread().getName()+":aquire()
at time:"+System.currentTimeMillis());
21  Thread.sleep(1000);
22  semaphore.release();
23  System.out.println(Thread.currentThread().getName()+":aquire()
at time:"+System.currentTimeMillis());
24  } catch (InterruptedException e) {
25  e.printStackTrace();
26  }
27 
28  }
29  }
30 }

打印结果：

CountDownLatch使用及应用场

CountDownLatch是什么？
CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
使用场景：
Zookeeper分布式锁,Jmeter模拟高并发等
CountDownLatch如何工作？
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务

API

1 CountDownLatch.countDown()
2 CountDownLatch.await();

CountDownLatch应用场景:
比如陪媳妇去看病。医院里边排队的人很多，如果一个人的话，要先看大夫，看完大夫再去排队交钱取药。
现在我们是双核，可以同时做这两个事（多线程）。假设看大夫花3秒钟，排队交费取药花5秒钟。我们同时搞的话，5秒钟我们就能完成，然后一起回家（回到主线程）。
代码如下：

1 /**
2  * 看大夫任务
3  */
4 public class SeeDoctorTask implements Runnable {
5  private CountDownLatch countDownLatch;
6 
7  public SeeDoctorTask(CountDownLatch countDownLatch){
8  this.countDownLatch = countDownLatch;
9  }
10 
11  public void run() {
12  try {
13  System.out.println("开始看医生");
14  Thread.sleep(3000);
15  System.out.println("看医生结束，准备离开病房");
16  } catch (InterruptedException e) {
17  e.printStackTrace();
18  }finally {
19  if (countDownLatch != null)
20  countDownLatch.countDown();
21  }
22  }
23 
24 }
25 
26 /**
27  * 排队的任务
28  */
29 public class QueueTask implements Runnable {
30 
31  private CountDownLatch countDownLatch;
32 
33  public QueueTask(CountDownLatch countDownLatch){
34  this.countDownLatch = countDownLatch;
35  }
36  public void run() {
37  try {
38  System.out.println("开始在医院药房排队买药....");
39  Thread.sleep(5000);
40  System.out.println("排队成功，可以开始缴费买药");
41  } catch (InterruptedException e) {
42  e.printStackTrace();
43  }finally {
44  if (countDownLatch != null)
45  countDownLatch.countDown();
46  }
47  }
48 }
49 
50 /**
51  * 配媳妇去看病，轮到媳妇看大夫时
52  * 我就开始去排队准备交钱了。
53  */
54 public class CountDownLaunchRunner {
55 
56  public static void main(String[] args) throws InterruptedExcep
tion {
57  long now = System.currentTimeMillis();
58  CountDownLatch countDownLatch = new CountDownLatch(2);
59 
60  new Thread(new SeeDoctorTask(countDownLatch)).start();
61  new Thread(new QueueTask(countDownLatch)).start();
62  //等待线程池中的2个任务执行完毕，否则一直
63  countDownLatch.await();
64  System.out.println("over，回家 cost:"+
(System.currentTimeMillis()‐now));
65  }
66 }