CyclicBarrier and CountDownLatch

转载 2013年12月04日 11:17:39

In multi-threaded design, I guess often encounter each other waiting threads and a thread or more threads wait for a scene, such as sophisticated multi-threaded computing and massive data processing, here to write my own experience and understanding.

I think there are many ways, if it is a simple 1:1 relationship, you can wait () and notify () to solve, like a lock and a key; If it is 1: N relationship, this one would need to care about N all states, and the most stupid way is one able to view the current state of N, poll asked whether the work done. And the good points finish after the solution is to tell an N, then N would have two kinds of options, or follow an order, or continue to do their other activities.

I think the traditional method should be able to achieve, and provides a CyclicBarrier and CountDownLatch JDK1.5 to solve the two problems, their difference is:

CyclicBarrier all threads waiting for each other, but CountDownLatch to one or more threads wait for the other thread. Similar differences between the top blue font, CountDownLatch not wait for other threads, as long as its done the work for their living to the, which is run () method in other tasks.

Example:

public static void testCountDownLatch() throws InterruptedException{
  CountDownLatch cdl=new CountDownLatch(2);
  ExecutorService exe=Executors.newFixedThreadPool(2);
   class Bow implements  Runnable{
    CountDownLatch cdl;
    public Bow(CountDownLatch cdl){
    this.cdl=cdl; 
    }
    public void run(){
     System.out.println("The bow is coming");
     System.out.println("kick a bow ");
     this.cdl.countDown();
     System.out.println("do other thing");
     }
   }
  exe.execute(new Bow(cdl));
  exe.execute(new Bow(cdl));
  exe.shutdown();
  System.out.println("Wait...");
    cdl.await();
    System.out.println("End..");
 
 }

        public static void main(String[] args) {
                try {
                        Test.testCountDownLatch();
                } catch (InterruptedException e) {
                }
        }



The output is:

The bow is coming
kick a bow
do other thing
Wait ...
The bow is coming
kick a bow
do other thing
End ..

As mentioned above do other thing is not affected.

Write a CyclicBarrier example:

public static void testCyclicBarrier() throws InterruptedException, BrokenBarrierException{
            CyclicBarrier barr=new CyclicBarrier(2+1);
                
                ExecutorService exe=Executors.newFixedThreadPool(2);
                 class Bow implements  Runnable{
                         CyclicBarrier barr;
                                public Bow(CyclicBarrier barr){
                                this.barr=barr; 
                                }
                                public void run(){
                                        System.out.println("The bow is coming");
                                        System.out.println("kick a down");
                                        try {
                                                barr.await();
                                        } catch (InterruptedException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        } catch (BrokenBarrierException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                        }
                                        System.out.println("do other thing");
                                        }
                        }
                exe.execute(new Bow(barr));
                exe.execute(new Bow(barr));
                exe.shutdown();
                System.out.println("Wait...");
                barr.await();
           System.out.println("End..");
        
        }


        public static void main(String[] args) {
                try {
                        Test.testCyclicBarrier();
                } catch (InterruptedException e) {
                }
                catch (BrokenBarrierException e) {
                }
        }



Output:

Wait ...
The bow is coming
kick a down
The bow is coming
kick a down
do other thing
End ..
do other thing

import java.util.concurrent.CountDownLatch;

public class TestThread
{
    static int cnt = 100;
    static int last = -1;
    static int type = 2;
    static int liveCnt = cnt;

    static CountDownLatch counter = new CountDownLatch(cnt);

    static class WorkThread extends Thread
    {
        Object lock = null;
        int id = -1;
        int sleep = -1;

        WorkThread(int id, Object lock)
        {
            this.id = id;
            this.lock = lock;
        }

        public void run()
        {
            try
            {
                work();
            } catch (Exception e)
            {
            }

            synchronized (lock)
            {
                //System.out.println("thread " + id + " done");

                last = sleep;
                liveCnt--;
                counter.countDown();
                lock.notify();
            }
        }

        private void work()
        {
            try
            {
                sleep = (int) (Math.random() * 1000 * 10);
                //System.out.println("thread " + id + " sleep=" + sleep);

                Thread.sleep(sleep);
            } catch (InterruptedException e)
            {
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        String lock = "lock";

        long start = System.currentTimeMillis();

        WorkThread[] workers = new WorkThread[cnt];
        for (int i = 0; i < cnt; i++)
        {
            workers[i] = new WorkThread(i, lock);
            workers[i].start();
        }

        switch (type)
        {
            //join 方式

            case 1 :
                for (Thread worker : workers)
                {
                    try
                    {
                        worker.join();
                    } catch (InterruptedException e)
                    {
                    }
                }
                break;

            //wait - notify 方式    

            case 2 :
                while (true)
                {
                    synchronized (lock)
                    {
                        if (liveCnt == 0)
                            break;

                        try
                        {
                            lock.wait();
                        } catch (InterruptedException e)
                        {
                        }
                    }
                }

                //CountDownLatch 方式

            case 3 :
                try
                {
                    counter.await();
                } catch (InterruptedException e)
                {
                }
                break;
        }

        long end = System.currentTimeMillis();
        System.out.println("type=" + type);
        System.out.println("All done, elapse: " + (end - start));
        System.out.println("last=" + last);
        System.out.println("delay=" + (end - start - last));
    }
}

闭锁CountDownLatch和栅栏CyclicBarrier之异同举例

CountDownLatch和CyclicBarrier的主要联系和区别如下: 1.闭锁CountDownLatch做减计数,而栅栏CyclicBarrier则是加计数。 2.CountDownLat...
  • gaolu
  • gaolu
  • 2015年05月29日 09:02
  • 10626

CountDownLatch、CyclicBarrier、Semaphore共同之处与区别以及各自使用场景

摘要: jdk1.5之后,java的concurrent包提供了一些并发工具类,比如CountDownLatch和CyclicBarrier,Semaphore。这里简要的比较一下他们的共同之处与区别...
  • jackyechina
  • jackyechina
  • 2016年10月26日 10:55
  • 2110

聊聊高并发(三十)解析java.util.concurrent各个组件(十二) 理解CyclicBarrier栅栏

这篇讲讲CyclicBarrier栅栏,从它的名字可以看出,它是可循环使用的。它的功能和CountDownLatch类似,也是让一组线程等待,然后一起开始往下执行。但是两者还是有几个区别 1. 等待...
  • ITer_ZC
  • ITer_ZC
  • 2014年11月12日 14:00
  • 3131

CountDownLatch 和 CyclicBarrier 的运用(含AQS详解)

  • 2017年03月25日 17:26
  • 59KB
  • 下载

多线程进阶之并发工具类第一篇:CountDownLatch、CyclicBarrier

在java.util.concurrent包下有4个非常有用的并发工具类。CountDownLatch、CyclicBarrier提供了一种并发流程控制的手段。 1.CountDownLatch探究:...
  • koushr
  • koushr
  • 2015年07月20日 18:22
  • 567

线程执行顺序——CountDownLatch、CyclicBarrier 、join()、线程池

本文主要围绕一个问题展开:线程执行顺序,比如某个线程在其他线程并发执行完毕后最后执行。join介绍join()是Thread类的一个方法,join()方法的作用是等待这个线程结束。t.join()方法...
  • lzx_2011
  • lzx_2011
  • 2017年03月10日 00:02
  • 821

Java多线程/并发24、Countdownlatch应用以及与CyclicBarrier的区别

有时候会有这样的需求:多个线程同时工作,其中几个可以随意的并发执行,但有一个线程需要等其他线程工作结束后,才能运行。举个例子,我们知道的迅雷下载,会同时开启多个线程分块下载一个大文件,每个线程下载固定...
  • soonfly
  • soonfly
  • 2017年05月07日 15:17
  • 694

黑马程序员-Condition条件对象、Semaphore、CyclicBarrier、倒计时门栓 CountDownLatch、Exchanger(实现两个线程之间数据交换

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流! ---------------------- --------------...
  • huohacker
  • huohacker
  • 2014年04月07日 14:24
  • 1152

记录一下CountDownLatch 和 CyclicBarrier 的使用例子

之前的面试有被提到过java.util.concurrent中解决并发的问题。 看Thinking in Java 学习一下其中一些构件的使用。 本文记录关于CountDownLatch  和 C...
  • Appletable
  • Appletable
  • 2016年08月18日 21:02
  • 184

四个并发工具类CountDownLatch,CyclicBarrier,Semaphore,Exchanger

1.等待多线程完成的CountDownLatch 简介 CountDownLatch 允许一个或多个线程等待其他线程完成操作。 应用场景 假如有这样一个需求...
  • VP_19951105
  • VP_19951105
  • 2017年07月05日 20:28
  • 154
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:CyclicBarrier and CountDownLatch
举报原因:
原因补充:

(最多只允许输入30个字)