Countdownlatch and join [concurrent programming]

Business scenario description ： Suppose there are three workers on an assembly line ：worker1,worker2,worker3. There is a task to be completed by the three of them ,worker3 The premise of starting this task is worker1 and worker2 Finished their work , and worker1 and worker2 They can work in parallel .

1.join Realization

public class CountDownLatchAndJoin {

    public static void main(String[] args) throws InterruptedException {

        //  Three independent worker threads 
        worker worker1 = new worker("worker1", (long) (Math.random()*4000));
        worker worker2 = new worker("worker2", (long) (Math.random()*4000));
        worker worker3 = new worker("worker3", (long) (Math.random()*4000));
//        worker worker1 = new worker("worker1", 6000);
//        worker worker2 = new worker("worker2", 5000);
//        worker worker3 = new worker("worker3", 5000);
        worker1.start();
        worker2.start();
        
        worker1.join();
        worker2.join();
        System.out.println(" Ready for work ...");

        worker3.start();

    }

    //  Workers 
    public static class worker extends Thread {
        //  name 
        private String name;
        // working hours 
        private long time;

        worker(String name, long time) {
            this.name = name;
            this.time = time;
        }

        public void run() {
            try {
                System.out.println(name + " start-up ");
                Thread.sleep(time);
                System.out.println(name + " completion of jobs , Time consuming =" + time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

result ：

worker2 start-up
worker1 start-up
worker1 completion of jobs , Time consuming =601
worker2 completion of jobs , Time consuming =2886
Ready for work …
worker3 start-up
worker3 completion of jobs , Time consuming =686

Can complete the work smoothly ,join It works by , Keep checking thread Survival , If alive, let the current thread forever wait, until thread Thread termination , Thread notifyAll It will be called , It can also be understood as join It means cutting in line

2.CountDownLatch Realization

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        //  The initialization counter is 2
        CountDownLatch countDownLatch = new CountDownLatch(2);

        //  Three independent worker threads 
        worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);
        worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);
        worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);
        worker1.start();
        worker2.start();

        //  When the counter is not 0 Waiting all the time 
        countDownLatch.await();

        System.out.println(" Ready for work ...");
        worker3.start();
    }

    public static class worker extends Thread {

        private String name;
        private long time;
        private CountDownLatch countDownLatch;

        worker(String name, long time, CountDownLatch countDownLatch) {
            this.name = name;
            this.time = time;
            this.countDownLatch = countDownLatch;
        }

        public void run() {
            System.out.println(name + "  It 's working ...");
            //  Minus one 
            countDownLatch.countDown();
            System.out.println(name + "  completion of jobs ...");
        }
    }
}

Create a counter for 2 Of CountDownLatch , Give Way Worker Hold this CountDownLatch example , When you finish your work , call countDownLatch.countDown() Method to decrement the counter 1.countDownLatch.await() Method will block until the counter is 0, The main thread will continue to execute .

Running results ：

worker1 It 's working ...
worker1 completion of jobs ...
worker2 It 's working ...
worker2 completion of jobs ...
Ready for work …
worker3 It 's working ...
worker3 completion of jobs ...
In terms of results , All solved the problem , But what is the difference between them ？

Business scenario ： hypothesis worker Our work can be divided into two stages ,work3 Just wait work1 and work2 After completing the first stage of their respective work, they can start their own work , Not the scene 1 You must wait work1 and work2 Don't start until they have finished all their work . such join It can't be achieved , We should use CountDownLatch To achieve .

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        //  The initialization counter is 5
        CountDownLatch countDownLatch = new CountDownLatch(5);

        //  Three independent worker threads 
        worker worker1 = new worker("worker1", (long) (Math.random() * 4000), countDownLatch);
        worker worker2 = new worker("worker2", (long) (Math.random() * 4000), countDownLatch);
        worker worker3 = new worker("worker3", (long) (Math.random() * 4000), countDownLatch);
        worker worker4 = new worker("worker4", (long) (Math.random() * 4000), countDownLatch);
        worker worker5 = new worker("worker5", (long) (Math.random() * 4000), countDownLatch);
        worker worker6 = new worker("worker6", (long) (Math.random() * 4000), countDownLatch);

        worker1.start();
        worker2.start();
        worker3.start();
        worker4.start();
        worker5.start();

        //  When the counter is not 0 Waiting all the time 
        countDownLatch.await();

        System.out.println(" Ready for work ...");
        worker6.start();
    }

    public static class worker extends Thread {

        private String name;
        private long time;
        private CountDownLatch countDownLatch;

        worker(String name, long time, CountDownLatch countDownLatch) {
            this.name = name;
            this.time = time;
            this.countDownLatch = countDownLatch;
        }

        public void run() {
            try {
                System.out.println(name + "  Work begins ...");
                Thread.sleep(time);
                System.out.println(name + "  The first stage is finished ... when :" + time);
                //  Counter minus one 
                countDownLatch.countDown();
                //  Suppose that the work of the second stage takes two seconds to complete 
                Thread.sleep(2000);
                System.out.println(name + "  The second stage is completed ... when :" + (time + 2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Run more times and find ： Threads 6 Wait until the front 5 The first stage of threads is completed , It's running , Running results ：

worker3 Work begins ...
worker2 Work begins ...
worker1 Work begins ...
worker4 Work begins ...
worker5 Work begins ...
worker3 The first stage is finished ... when :1410
worker5 The first stage is finished ... when :2022
worker2 The first stage is finished ... when :2273
worker1 The first stage is finished ... when :2856
worker3 The second stage is completed ... when :3410
worker4 The first stage is finished ... when :3430
Ready for work …
worker6 Work begins ...
worker5 The second stage is completed ... when :4022
worker2 The second stage is completed ... when :4273
worker1 The second stage is completed ... when :4856
worker4 The second stage is completed ... when :5430
worker6 The first stage is finished ... when :3773
worker6 The second stage is completed ... when :5773

summary ： call thread.join() Method must wait thread completion of enforcement , The current thread can continue to execute , and CountDownLatch More flexible control is provided through counters , As long as it is detected that the counter is 0 The current thread can execute down without taking care of the corresponding thread Whether the implementation is completed .