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和Semaphore区别

下面对上面说的三个辅助类进行一个总结:   1)CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:     CountDownLatch一般用...

Java线程(CountDownLatch、CyclicBarrier、Semaphore)并发控制工具类

尽管线程是比较的神秘且具有一定的不可控性,但我们依然可以尽可能地对其进行管理和“控制” 运用CountDownLatch、CyclicBarrier、Semaphore等 在很大程度上可以帮我们对线程...
  • only06
  • only06
  • 2016年11月05日 19:06
  • 210

同步辅助类 CountDownLatch、CyclicBarrier作用

对于某种需求,比如 A,B,C 三个并发的线程全部处理完后才执行 D

【java多线程】CountDownLatch与CyclicBarrier

CountDownLatch 闭锁1.引入Java 5.0 在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。2.定义CountDownLatch 一个同步辅助...

Java并发工具类CountDownLatch和CyclicBarrier

1.CountDownLatchCountDownLatch允许一个或多个线程等待其他线程完成操作,其构造函数接收一个int型的参数作为计数器,若想等待N个点完成,就传人N。此处的N个点,可指N个线程...

java并发编程——八 理解分析并发组件-CountDownLatch\CyclicBarrier\Exchanger\Semaphore

从这章开始介绍 java.concurrent.*中的常用并发工具类,并附带有趣的示例CountDownLatch 概要 调用countDownLatch.countDown() count计数器-1...
  • lemon89
  • lemon89
  • 2016年03月26日 21:02
  • 500

[Java并发包学习五]CountDownLatch和CyclicBarrier介绍

概述 JDK中提供了一些用于线程之间协同等待的工具类,CountDownLatch和CyclicBarrier就是最典型的两个线程同步辅助类。下面分别详细介绍这两个类,以及他们之间的异同点。 ...

多线程CountDownLatch和CyclicBarrier的区别 以及举例

在网上看到很多人对于CountDownLatch和CyclicBarrier的区别简单理解为CountDownLatch是一次性的,而CyclicBarrier在调用reset之后还可以继续使用。那如...
  • paul342
  • paul342
  • 2015年11月05日 14:05
  • 543

java Thread学习(新类库CountDownLatch+CyclicBarrier+DelayQueue)

新类库的构件 CountDownLatch:用来同步一个或多个任务,强制它们等待其它任务的一组操作完成 CyclicBarrier:用来同步一组任务,当所有任务都进入等待时,唤醒所有线程。也可以在唤醒...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:CyclicBarrier and CountDownLatch
举报原因:
原因补充:

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