CyclicBarrier and CountDownLatch

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));
    }
}