countdownlatch

ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。 ZooKeeper的架构通过冗余服务实现高可用性。因此，如果第一次无应答，客户端就可以询问另一台ZooKeeper主机。ZooKeeper节点将它们的数据存储于一个分层的命名空间，非常类似于一个文件系统或一个前缀树结构。客户端可以在节点读写，从而以这种方式拥有一个共享的配置服务。更新是全序的。 基于ZooKeeper分布式锁的流程 在zookeeper指定节点（locks）下创建临时顺序节点node_n 获取locks下所有子节点children 对子节点按节点自增序号从小到大排序 判断本节点是不是第一个子节点，若是，则获取锁；若不是，则监听比该节点小的那个节点的删除事件 若监听事件生效，则回到第二步重新进行判断，直到获取到锁 具体实现 下面就具体使用java和zookeeper实现分布式锁，操作zookeeper使用的是apache提供的zookeeper的包。 通过实现Watch接口，实现process(WatchedEvent event)方法来实施监控，使CountDownLatch来完成监控

package com.hiberate.huijpa; import java.io.*; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public class Client { private int[] nums; public Client(int nums) { this.nums = new int[nums]; } public int calc(String line, int index, CountDownLatch latch){ String[] nus = line.split(","); int total=0; for (String num : nus) { total += Integer.parseInt(num); } System.out.println(Thread.currentThread()+" 结果："+total); nums[index] = total; latch.countDown(); return total; } public int sum(){ int total=0; for (int num : nums) { total += num; } return

AQS的几个同步组件 CountDownLatch 一个线程或多个线程一直等待，直到其他线程执行的操作完成才继续执行。 应用：并行计算。 计数器是不能重计的，计数值不能往上加，类似操作只有一次。 使用时首先new一个countDownLatch，构造方法中放入计数，然后在一个线程中调用await方法，这个线程就会进入等待状态，其他线程中调用countDown方法减少这个计数，直至降到0时，await方法阻塞的线程会被唤醒继续工作，为保证顺利执行，countDown方法一定要放在finally块里保证。 countdownLatch的await方法还可以设置超时时间，第一参数是数字，第二个是单位，超过这个时间await的线程就会被唤醒，之前给定的线程还会继续执行完。 Semaphore（信号量） 控制某个资源可以被多少个线程访问 应用场景：资源有限的并发控制，如数据库连接。 使用时首先new一个semaphere，然后参数为可以并发访问的个数，如20。 然后在线程中调用acquire方法和release方法，把要控制并发的执行部分放入这两部分之间，然后就完成了，这样执行时，同时访问的线程最多只有20个，这样在控制并发场景数据库连接时，就不会因为获取连接得到异常。 acquire方法和release方法可以同时获取或释放多个许可，传入许可数当做方法参数即可。 还可以完成这样的场景

一、CountDownLatchDemo package com.duchong.concurrent; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CountDownLatch; /* * CountDownLatch ：阻塞主线程，等子线程完成 */ public class CountDownLatchDemo { /** * 存放子线程产生的结果 */ private static ConcurrentHashMap<String,Integer> resultMap =new ConcurrentHashMap<>(); public static void main(String[] args) { final CountDownLatch latch = new CountDownLatch(5); SubThread subThread = new SubThread(latch); for (int i = 0; i <=4; i++) { new Thread(subThread).start(); } try { //阻塞主线程 latch.await(); } catch

java5 中 ，提供了几个并发工具类 ，Semaphore CountDownLatch CyclicBarrier，在并发编程中非常实用。前两者通过 内部类sync 继承AQS，使用共享资源的模式，AQS的实现可参考我的另一篇 AQS 实现分析 ，前两者根据各自功能需求 ， 各自内部实现tryAcquireShared（获取资源）、tryReleaseShared（释放）。来定义什么条件 下来获取与释放。而CyclicBarrier内部通过Reentrantlock与Condition组合的方式实现。 Semaphore 与Reentrantlock类似，也有公平和非公平的机制。这里就不在分析了，默认是非公平的。 通过acquire 获取 Semphore public void acquire() throws InterruptedException { sync.acquireSharedInterruptibly(1); //非独占模式 } AQS public final void acquireSharedInterruptibly(int arg) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); if

在上篇文章本人粗略地整理了AbstractQueuedSynchronizer和ReentrantLock的源码要点。其实，在java.util.concurrent包中，AbstractQueuedSynchronizer的应用非常广泛，而不局限于在ReentrantLock中的实现， 本文简要介绍下AbstractQueuedSynchronizer在Semaphore、ReentrantReadWriteLock等类中的应用 。 0. 回顾 上文在介绍AQS的时候，介绍了AQS和ReentrantLock类中的Sync子类互相配合完成可重入锁的实现，在这其中AQS所提供的是一套灵活和完整的队列处理机制。由于在AQS中已经提供了完整的队列处理机制，通常是不需要扩展的子类Override的。同时，AQS又提供了state属性和tryAcquire()/tryRelease()等方法，而这些正是需要子类根据具体的需求逻辑灵活实现的扩展点。从ReentrantLock、ReentrantReadWriteLock、Semaphore和CountDownLatch的实现来看，通常是在这些工具类的中封装实现自己独有的Sync内部类，而Sync就是对AQS的扩展实现。 1. Semaphore 学习操作系统理论课的时候，教材上应该都会讲过信号量这种概念，java.util

CountDownLatch ：一个门闩，作用是将某个线程关在门外，等门里的人分赃完毕（计数为0）的时候，才会打开门，让外面的那个线程执行。 这玩意很有用，有利于我们控制许多线程，有序执行业务。 demo:r2必须要等r1执行完才可以执行。 package com.gcc; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; public class CountDownLatchTest { public static void main(String[] args) { CountDownLatch c = new CountDownLatch(1); Runnable r1 = ()->{ try { System.out.println("执行r1............"); System.out.println("sleep 1s"); Thread.sleep(1000L); c.countDown(); } catch (InterruptedException e) { e.printStackTrace(); } }; Runnable r2 = ()->{ try { c.await(60L,TimeUnit.SECONDS); System.out

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。 CountDownLatch是一个非常实用的多线程控制工具类。常用的就下面几个方法： CountDownLatch( int count) //实例化一个倒计数器，count指定计数个数 countDown() // 计数减一 await() //等待，当计数减到0时，所有线程并行执行 CountDownLatch在我工作的多个场景被使用，算是用的很频繁的了，比如我们的API接口响应时间被要求在200ms以内，但是如果一个接口内部依赖多个三方/外部服务，那串行调用接口的RT必然很久，所以个人用的最多的是接口RT优化场景，内部服务并行调用。 对于倒计数器，一种典型的场景就是火箭发射。在火箭发射前，为了保证万无一失，往往还要进行各项设备、仪器的检测。只有等到所有的检查完毕后，引擎才能点火。那么在检测环节当然是多个检测项可以同时进行的。代码实现： public class CountDownLatchDemo implements Runnable{ static final CountDownLatch latch = new CountDownLatch

线程这块的一些工具类，基本都会以原理为主，通过分析别人代码的设计和实现，给自己提供积累一些方法和工具。 Condition 在前面学习 synchronized 的时候，有讲到 wait/notify 的 基本使用，结合 synchronized 可以实现对线程的通信。那 么这个时候我就在思考了，既然 J.U.C 里面提供了锁的实现 机制，那 J.U.C 里面有没有提供类似的线程通信的工具呢？ 发现了一个 Condition 工具类。 Condition 是一个多线程协调通信的工具类，可以让某些线 程一起等待某个条件（condition），只有满足条件时，线程 才会被唤醒 Condition 的基本使用 ConditionWait public class ConditionDemoWait implements Runnable{ 　　private Lock lock;　　private Condition condition; 　　public ConditionDemoWait(Lock lock, 　　Condition condition){ 　　　　this.lock=lock; 　　　　this.condition=condition; 　　} 　　@Override 　　public void run() { 　　　　System.out.println(

本站小福利 点我获取阿里云优惠券 原文作者：github：CL0610/Java-concurrency 免责声明： 1.本文所转载文章均来自公开网络。 2.如果出处标注有误或侵犯到原著作者权益，请联系删除。 3.转载文章请注明原文链接和作者，否则产生的任何版权纠纷均与本站无关。 1. 倒计时器CountDownLatch 在多线程协作完成业务功能时，有时候需要等待其他多个线程完成任务之后，主线程才能继续往下执行业务功能，在这种的业务场景下，通常可以使用Thread类的join方法，让主线程等待被join的线程执行完之后，主线程才能继续往下执行。当然，使用线程间消息通信机制也可以完成。其实，java并发工具类中为我们提供了类似“倒计时”这样的工具类，可以十分方便的完成所说的这种业务场景。 为了能够理解CountDownLatch，举一个很通俗的例子，运动员进行跑步比赛时，假设有6个运动员参与比赛，裁判员在终点会为这6个运动员分别计时，可以想象没当一个运动员到达终点的时候，对于裁判员来说就少了一个计时任务。直到所有运动员都到达终点了，裁判员的任务也才完成。这6个运动员可以类比成6个线程，当线程调用CountDownLatch.countDown方法时就会对计数器的值减一，直到计数器的值为0的时候，裁判员（调用await方法的线程）才能继续往下执行。