Java - CountDownLatch

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/PeersLee/article/details/79948807

package Chapter02;

import java.util.concurrent.CountDownLatch;

/*
 * CountDownLatch：
 * 1. 如果count 计数不为0时，则当前线程呈wait 状态
 * 2. await 方法判断计数是否为0，不为0 则等待
 * 3. countDown 方法将计数减1
 */

public class _01_Run {

	public static void main(String[] args) {
		try {
			CountDownLatch comingTag = new CountDownLatch(10); //运动员
			CountDownLatch waitTag = new CountDownLatch(1); //裁判
			CountDownLatch waitRunTag = new CountDownLatch(10);
			CountDownLatch beginTag = new CountDownLatch(1);
			CountDownLatch endTag = new CountDownLatch(10);
			
			System.out.println("[解说员] 等待所有选手进入体育场.");
			MyThread[] threads = new MyThread[10];
			for (int i = 0; i < threads.length; i++) {
				threads[i] = new MyThread(comingTag, waitTag, waitRunTag,
						beginTag, endTag);
				threads[i].start();
			}
			comingTag.await();
			
			System.out.println("[裁判] “巡视5秒.”");
			Thread.sleep(5000);
			System.out.println("[裁判] 各就各位.");
			waitTag.countDown();
			waitRunTag.await();
			
			Thread.sleep(2000);
			System.out.println("[裁判] “啪.”");
			beginTag.countDown();
			endTag.await();
			
			System.out.println("[解说员] 比赛结束.");
		} catch (Exception e) { }
	}
	
	static class MyThread extends Thread {
		
		private CountDownLatch comingTag; //裁判等待所有运动员到来
		private CountDownLatch waitTag; //运动员等待裁判说准备
		private CountDownLatch waitRunTag; //运动员做好准备，等待发令枪
		private CountDownLatch beginTag; //起跑
		private CountDownLatch endTag; //所有运动员到达终点
		
		public MyThread(CountDownLatch comingTag, CountDownLatch waitTag,
				CountDownLatch waitRunTag, CountDownLatch beginTag,
				CountDownLatch endTag) {
			super();
			this.comingTag = comingTag;
			this.waitTag = waitTag;
			this.waitRunTag = waitRunTag;
			this.beginTag = beginTag;
			this.endTag = endTag;
		}
		
		@Override
		public void run() {
			try {
				String runner = this.getName();
				
				//热身
				System.out.println("运动员 "+ runner+ " 正走向起跑点.");
				Thread.sleep((int)(Math.random()* 10000));	
				System.out.println("运动员"+ runner+ " 已到达起跑点.");
				comingTag.countDown(); 
				System.out.println("运动员"+ runner+ " 等待准备.");
				waitTag.await(); 
				
				//蹲下
				System.out.println("运动员"+ runner+ " 等待发令.");
				Thread.sleep((int)(Math.random()* 10000));	
				waitRunTag.countDown();
				beginTag.await();
				
				//跑步
				System.out.println("运动员"+ runner+ " 在跑道上奔跑.");
				Thread.sleep((int)(Math.random()* 10000));
				System.out.println("运动员"+ runner+ " 到达终点.");
				endTag.countDown();
			} catch (Exception e) {	}
		}
	}
}

[解说员] 等待所有选手进入体育场.
运动员 Thread-0 正走向起跑点.
运动员 Thread-2 正走向起跑点.
运动员 Thread-3 正走向起跑点.
运动员 Thread-4 正走向起跑点.
运动员 Thread-1 正走向起跑点.
运动员 Thread-6 正走向起跑点.
运动员 Thread-5 正走向起跑点.
运动员 Thread-7 正走向起跑点.
运动员 Thread-9 正走向起跑点.
运动员 Thread-8 正走向起跑点.
运动员Thread-4 已到达起跑点.
运动员Thread-4 等待准备.
运动员Thread-7 已到达起跑点.
运动员Thread-7 等待准备.
运动员Thread-3 已到达起跑点.
运动员Thread-3 等待准备.
运动员Thread-6 已到达起跑点.
运动员Thread-6 等待准备.
运动员Thread-2 已到达起跑点.
运动员Thread-2 等待准备.
运动员Thread-9 已到达起跑点.
运动员Thread-9 等待准备.
运动员Thread-0 已到达起跑点.
运动员Thread-0 等待准备.
运动员Thread-1 已到达起跑点.
运动员Thread-1 等待准备.
运动员Thread-8 已到达起跑点.
运动员Thread-8 等待准备.
运动员Thread-5 已到达起跑点.
运动员Thread-5 等待准备.
[裁判] “巡视5秒.”
[裁判] 各就各位.
运动员Thread-4 等待发令.
运动员Thread-3 等待发令.
运动员Thread-2 等待发令.
运动员Thread-0 等待发令.
运动员Thread-7 等待发令.
运动员Thread-8 等待发令.
运动员Thread-5 等待发令.
运动员Thread-1 等待发令.
运动员Thread-9 等待发令.
运动员Thread-6 等待发令.
[裁判] “啪.”
运动员Thread-4 在跑道上奔跑.
运动员Thread-8 在跑道上奔跑.
运动员Thread-6 在跑道上奔跑.
运动员Thread-3 在跑道上奔跑.
运动员Thread-9 在跑道上奔跑.
运动员Thread-1 在跑道上奔跑.
运动员Thread-2 在跑道上奔跑.
运动员Thread-7 在跑道上奔跑.
运动员Thread-5 在跑道上奔跑.
运动员Thread-0 在跑道上奔跑.
运动员Thread-1 到达终点.
运动员Thread-0 到达终点.
运动员Thread-2 到达终点.
运动员Thread-9 到达终点.
运动员Thread-8 到达终点.
运动员Thread-5 到达终点.
运动员Thread-3 到达终点.
运动员Thread-4 到达终点.
运动员Thread-7 到达终点.
运动员Thread-6 到达终点.
[解说员] 比赛结束.