java 多线程中的 Semaphore cyclicbarrier countdownlatch
//semaphore java中表示 同时可以有多少个线程执行；
eg：
public static void main(String[] args) {
//定义只能有两个线程同时运行
final java.util.concurrent.Semaphore semaphore = new java.util.concurrent.Semaphore(2);
final Random random = new Random(47);
//创建10个线程
for (int i = 0; i< 10 ; i++) {
new Thread ("Thread_" + i) {
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("====>> 我是线程：" + this.getName() + "我开始执行");
int time = random.nextInt(5) * 1000;
TimeUnit.MILLISECONDS.sleep(time);
System.out.println("====>> 我是线程 ：" + this.getName() + "我结束了执行");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
};
}.start();
}
}
结果信息为：
====>> 我是线程：Thread_1我开始执行
====>> 我是线程：Thread_0我开始执行
====>> 我是线程 ：Thread_0我结束了执行
====>> 我是线程：Thread_4我开始执行
====>> 我是线程 ：Thread_1我结束了执行
====>> 我是线程：Thread_2我开始执行
====>> 我是线程 ：Thread_4我结束了执行
====>> 我是线程：Thread_6我开始执行
====>> 我是线程 ：Thread_2我结束了执行
====>> 我是线程：Thread_7我开始执行
====>> 我是线程 ：Thread_6我结束了执行
====>> 我是线程：Thread_3我开始执行
//cyclicbarrier 在java中表示的是 当多线程同时运行到某一步的时候，执行下一步； 这里启动的线程数和定义的线程数相同
public static void main(String[] args) {
final CyclicBarrier cyclicBarrier = new CyclicBarrier(5 , new Runnable() {
@Override
public void run() {
System.out.println("大家都到齐了，开始下一步");
}
});
ExecutorService es = Executors.newCachedThreadPool();
for (int i = 0; i < 5 ; i++) {
final int num = i;
es.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("==>>线程：" + num + " 开始聚齐");
cyclicBarrier.await();
System.out.println("==>>线程：" + num + " 开始爬山");
cyclicBarrier.await();
System.out.println("==>>线程：" + num + " 开始游泳");
cyclicBarrier.await();
System.out.println("==>>线程：" + num + " 开始回家");
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
});
}
}
结果信息为：
==>>线程：0 开始聚齐
==>>线程：3 开始聚齐
==>>线程：1 开始聚齐
==>>线程：2 开始聚齐
==>>线程：4 开始聚齐
大家都到齐了，开始下一步
==>>线程：3 开始爬山
==>>线程：0 开始爬山
==>>线程：1 开始爬山
==>>线程：2 开始爬山
==>>线程：4 开始爬山
大家都到齐了，开始下一步
。。。。。。。
大家都到齐了，开始下一步
==>>线程：2 开始回家
==>>线程：0 开始回家
==>>线程：3 开始回家
==>>线程：1 开始回家
==>>线程：4 开始回家
countDownLatch java中表示阻塞一次
public static void main(String[] args) {
processOneGroup("分组1");
processOneGroup("分组2");
}
public static void processOneGroup(final String groupName) {
final CountDownLatch cdl_start = new CountDownLatch(1);
final CountDownLatch cdl_end = new CountDownLatch(5);
System.out.println("==========================>\n分组：" + groupName + "比赛开始：");
for (int i = 0; i < 5; i++) {
new Thread("thread_" + i){
public void run() {
try {
System.out.println("我是线程组：【" + groupName + "】，第：" + this.getName() + " 号线程，我已经准备就绪");
cdl_start.await();//等待发出指令
System.out.println("我是线程组：【" + groupName + "】，第：" + this.getName() + " 号线程，我已执行完成");
cdl_end.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
}
try {
TimeUnit.MILLISECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("各就各位，预备：");
cdl_start.countDown();
try {
cdl_end.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
运行结果为：
==========================>
分组：分组1比赛开始：
我是线程组：【分组1】，第：thread_0 号线程，我已经准备就绪
我是线程组：【分组1】，第：thread_1 号线程，我已经准备就绪
我是线程组：【分组1】，第：thread_4 号线程，我已经准备就绪
我是线程组：【分组1】，第：thread_2 号线程，我已经准备就绪
我是线程组：【分组1】，第：thread_3 号线程，我已经准备就绪
各就各位，预备：
我是线程组：【分组1】，第：thread_0 号线程，我已执行完成
我是线程组：【分组1】，第：thread_3 号线程，我已执行完成
我是线程组：【分组1】，第：thread_2 号线程，我已执行完成
我是线程组：【分组1】，第：thread_4 号线程，我已执行完成
我是线程组：【分组1】，第：thread_1 号线程，我已执行完成
==========================>
分组：分组2比赛开始：
我是线程组：【分组2】，第：thread_0 号线程，我已经准备就绪
我是线程组：【分组2】，第：thread_1 号线程，我已经准备就绪
我是线程组：【分组2】，第：thread_2 号线程，我已经准备就绪
我是线程组：【分组2】，第：thread_3 号线程，我已经准备就绪
我是线程组：【分组2】，第：thread_4 号线程，我已经准备就绪
各就各位，预备：
我是线程组：【分组2】，第：thread_0 号线程，我已执行完成
我是线程组：【分组2】，第：thread_4 号线程，我已执行完成
我是线程组：【分组2】，第：thread_2 号线程，我已执行完成
我是线程组：【分组2】，第：thread_3 号线程，我已执行完成
我是线程组：【分组2】，第：thread_1 号线程，我已执行完成