Java 并发编程中的 CountDownLatch 锁用于多个线程同时开始运行或主线程等待子线程结束

Java 5 开始引入的 Concurrent 并发软件包里面的 CountDownLatch 其实可以把它看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值。CountDownLatch的一个非常典型的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法,其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法,这个调用await()方法的任务将一直阻塞等待,直到这个CountDownLatch对象的计数值减到0为止。 所以,CountDownLatch类可以用于控制多个线程同时开始运行,或者用于主线程等待所有子线程都结束。
举个例子,有三个工人在为老板干活,这个老板有一个习惯,就是当三个工人把一天的活都干完了的时候,他就来检查所有工人所干的活。记住这个条件:三个工人先全部干完活,老板才检查。所以在这里用Java代码设计两个类,Worker代表工人,Boss代表老板,具体的代码实现如下:

 1 public class Worker implements Runnable{
 2
 3     private CountDownLatch downLatch;
 4     private String name;
 5
 6     public Worker(CountDownLatch downLatch, String name){
 7         this.downLatch = downLatch;
 8         this.name = name;
 9     }
10
11     public void run() {
12         this.doWork();
13         try
14 {
15             TimeUnit.SECONDS.sleep(new Random().nextInt(10));
16         }catch(InterruptedException ie){
17         }
18        System.out.println(this.name + "活干完了!");
19         this.downLatch.countDown();
20
21     }
22
23     private void doWork()
24     {
25        System.out.println(this.name + "正在干活!");
26     }
27
28 }
29
30 ==================
31
32 public class Boss implements Runnable {
33
34     private CountDownLatch downLatch;
35
36     public Boss(CountDownLatch downLatch){
37         this.downLatch = downLatch;
38     }
39
40     public void run() {
41         System.out.println("老板正在等所有的工人干完活......");
42         try {
43             this.downLatch.await();
44         } catch (InterruptedException e) {
45         }
46         System.out.println("工人活都干完了,老板开始检查了!");
47     }
48
49 }
50
51
52 ============================
53
54 public class CountDownLatchDemo {
55
56     public static void main(String[] args) {
57        ExecutorService executor = Executors.newCachedThreadPool();
58
59         CountDownLatch latch = new CountDownLatch(3);
60
61         Worker w1 = new Worker(latch,"张三");
62         Worker w2 = new Worker(latch,"李四");
63         Worker w3 = new Worker(latch,"王二");
64
65        Boss boss = new Boss(latch);
66
67         executor.execute(w3);
68         executor.execute(w2);
69         executor.execute(w1);
70         executor.execute(boss);
71
72         executor.shutdown();
73     }
74 }
时间: 2024-10-10 10:29:47

Java 并发编程中的 CountDownLatch 锁用于多个线程同时开始运行或主线程等待子线程结束的相关文章

Java实现主线程等待子线程

本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明: 1.使用Thread的join()方法,join()方法会阻塞主线程继续向下执行. 2.使用Java.util.concurrent中的CountDownLatch,是一个倒数计数器.初始化时先设置一个倒数计数初始值,每调用一次countDown()方法,倒数值减一,他的await()方法会阻塞当前进程,直到倒数至0. join方式代码如下: [java] view plain copy package com.test.thread

JAVA进阶----主线程等待子线程各种方案比较(转)

创建线程以及管理线程池基本理解 参考原文链接:http://www.oschina.net/question/12_11255?sort=time 一.创建一个简单的java线程 在 Java 语言中,一个最简单的线程如下代码所示: Java代码   Runnable runnable = new Runnable(){ public void run(){ System.out.println("Run"); } } 可通过下面一行代码来启动这个线程: new Thread(runn

Java并发编程原理与实战六:主线程等待子线程解决方案

本文将研究的是主线程等待所有子线程执行完成之后再继续往下执行的解决方案 public class TestThread extends Thread { public void run() { System.out.println(this.getName() + "子线程开始"); try { // 子线程休眠五秒 Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.

Java多线程--让主线程等待子线程执行完毕

使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行,那么接下来介绍一种简单的方式使主线程等待. java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待: public class ThreadWait { public static void main(String[] args) throws InterruptedException { int threadNumber

Java线程池主线程等待子线程执行完成

今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程,  往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式. 站在 主线程的角度, 我们可以分为主动式和被动式. 主动式指主线主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程被动的等待子线程的结束, 很明

Java多线程协作CountDownLatch,主线程等待子线程结束

CountDownLatch,一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待. 主要方法 public CountDownLatch(int count);构造方法参数指定了计数的次数 public void countDown(); countDown方法,当前线程调用此方法,则计数减一 public void await() awaint方法,调用此方法会一直阻塞当前线程,直到计时器的值为0 ===============================

java并发编程中CountDownLatch和CyclicBarrier的使用

转自:http://blog.csdn.net/hbzyaxiu520/article/details/6183714 在多线程程序设计中,经常会遇到一个线程等待一个或多个线程的场景,遇到这样的场景应该如何解决? 如果是一个线程等待一个线程,则可以通过await()和notify()来实现: 如果是一个线程等待多个线程,则就可以使用CountDownLatch和CyclicBarrier来实现比较好的控制. 下面来详细描述下CountDownLatch的应用场景: 例如:百米赛跑:8名运动员同时

Android笔记(三十二) Android中线程之间的通信(四)主线程给子线程发送消息

之前的例子都是我们在子线程(WorkerThread)当中处理并发送消息,然后在主线程(UI线程)中获取消息并修改UI,那么可以不可以在由主线程发送消息,子线程接收呢?我们按照之前的思路写一下代码: package cn.lixyz.handlertest; import android.app.Activity; import android.os.Bundle; import android.os.Handler; import android.os.Message; import andr

在C#中主线程和子线程如何实现互相传递数据

在C#中主线程和子线程如何实现互相传递数据 老帅 在C#中创建线程Thread时,可以有多种方法,而主线程和子线程之间又如何实现互相传递数据,每种创建方法传递参数的效果是不同的,逐一看一下:  一.不带参数创建Thread 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 using System;  using System.Collections.Generic;  using System.Text;  using Sy