java 线程馒头_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

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 

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 

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 号线程，我已执行完成