countdownlatch如何实现java主线程等待子线程执行完毕之后再执行

countdownlatch和synchronized的区别

CountDownLatch 1、类介绍 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数 初始化 CountDownLatch。

由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。

之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。

这种现象只出现一次——计数无法被重置。

一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行 2、使用场景 在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。

这个时候就可以使用CountDownLatch。

CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

1.synchronized的意义 synchronized用于多线程设计，有了synchronized关键字，多线程程序的运行结果将变得可以控制。

synchronized关键字用于保护共享数据。

2.synchronized实现同步的机制 synchronized依靠"锁"机制进行多线程同步，"锁"有2种，一种是对象锁，一种是类锁。

3.此下面2种是依靠对象锁锁定，初始化一个对象时，自动有一个对象锁。

synchronized ｛普通方法｝依靠对象锁工作，多线程访问ynchronized方法，一旦某个进程抢得锁之后，其他的进程只有排队对待。

synchronized void method{}功能上，等效于 void method{ synchronized(this) } } synchronized ｛修饰代码块}的作用不仅于此，synchronized void method{}整个函数加上synchronized块，效率并不好。

在函数内部，可能我们需要同步的只是小部分共享数据，其他数据，可以自由访问，这时候我们可以用 synchronized(表达式){//语句}更加精确的控制。

4.synchronized ｛static方法}此代码块等效于 void method{ synchronized(Obl.class) } } 使用该类的类对象的锁定去做线程的共享互斥. 5.synchronized ｛run方法｝run方法的锁定. 这个举例比较好说。

public class MyThread implement Runnable{ public void run(){ for(int i=0;i<10;i++){ System.out.println(i+" "); } } } 如果在主程序多线程运行 MyThread t=new MyThread (); new Thread(t).start(); new Thread(t).start(); new Thread(t).start(); new Thread(t).start(); 其结果是混乱不堪的。

如果加了synchronized当前线程取完所有数据后，才会释放锁，所以结果可以预知。

4个线程输出总是0,1...9

countdownlatch怎么读

countdown latch 的读法 countdown 单词音标是: 英[?ka?ntda?n] 美[?ka?nt?da?n] latch 单词音标是: 英[l?t?] 美[l?t?]

如何解决java接口访问ZooKeeper时的connectionloss错误

常见错误日志如下： org.apache.zookeeper.KeeperException$ConnectionLossException: KeeperErrorCode = ConnectionLoss 1. 原因： 是因为ZooKeeper建立连接时采用异步操作，连接操作后并不能保证ZK连接已成功。

如果在ZK连接成功前的这个小时间窗口去访问ZK，就会碰到如上错误。

2. 解决思路 我们在新建ZK连接后要等一段时间，保证连接成功后再访问ZK。

3. 网上比较赞同的解决方案: 主要利用两个Java类： （1）java.util.concurrent.CountDownLatch： 一个同步辅助类，类似倒数计数，直到计数器为0时才能对资源“解锁”。

未解锁前等待该资源的进程只能被阻塞。

主要方法： public CountDownLatch(int count); /* 构造函数,参数指定计数次数 */ public void countDown(); /* 当前线程调用此函数，则计数减一 */ public void await() throws InterruptedException; /* 此函数会一直阻塞当前线程，直到计时器的值为0为止 */ （.apache.zookeeper.Watcher ZooKeeper有一个很有用的功能，就是集群上每一个变化都可以通知到自定义的Watchcer。

来来来，用java写个线程，启动运行，然后判断它是否在执行，如果没有在执行则启动它，谁来写个简单滴

package?test; import?java.util.concurrent.CountDownLatch; import?java.util.concurrent.Executor; import?java.util.concurrent.Executors; public?class?WatchThread?{ public?void?testThread()?throws?InterruptedException?{ int?threadNum?=?10; //?初始化countDown CountDownLatch?threadSignal?=?new?CountDownLatch(threadNum); //?创建固定长度的线程池 Executor?executor?=?Executors.newFixedThreadPool(threadNum); for?(int?i?=?0;?i?<?threadNum;?i++)?{?//?开threadNum个线程 Runnable?task?=?new?TestThread(threadSignal); //?执行 executor.execute(task); } threadSignal.await();?//?等待所有子线程执行完 //?do?work System.out.println(Thread.currentThread().getName()?+?""); } /** *?测试函数 */ public?static?void?main(String[]?args)?throws?InterruptedException?{ WatchThread?test?=?new?WatchThread(); test.testThread(); } private?class?TestThread?implements?Runnable?{ private?CountDownLatch?threadsSignal; public?TestThread(CountDownLatch?threadsSignal)?{ this.threadsSignal?=?threadsSignal; } public?void?run()?{ System.out.println(Thread.currentThread().getName()?+?"开始..."); //?do?shomething System.out.println("开始了线程：：：："?+?threadsSignal.getCount()); //?线程结束时计数器减1 threadsSignal.countDown(); System.out.println(Thread.currentThread().getName()?+?"结束.?还有" +?threadsSignal.getCount()?+?"?个线程"); } } }

怎么让它到这里停止，等主线任务线程里的任务全做完

要实现这个情况，必须知道以下几点1、java中线程的结束是由run方法运行完成后自动结束的2、在main线程(主线程)中，需要得到所有线程的引用。

3、知道jdk提供的CountDownLatch的用法例子如下：publicstaticvoidmain(String[]args)throwsInterruptedException{//CountDownLatch作为计数器纪录有几个线程，例如有2个线程CountDownLatchlatch=newCountDownLatch(2);Workerworker1=newWorker(latch);Workerworker2=newWorker(latch);worker1.start();//启动线程worker2.start();////等待所有工人完成工作latch.await();System.out.println("allworkdoneat"+sdf.format(newDate()));}classWorkerextendsThread{privateCountDownLatchlatch;publicWorker(CountDownLatchlatch){this.latch=latch;}publicvoidrun(){xxxxx//在run方法结束之前，讲线程计数器减一latch.countDown();}}

如何实现java主线程等待子线程执行完毕之后再执行

java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能 例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个 Thread t = new Thread() { public void run() { try { //TODO 你的应用 } catch (Exception e) { //TODO 异常处理 } finally { latch.countDown(); //这句是关键 System.out.println("ok"); //5个线程都跑完后输出 } } }; t.start(); 然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。