Java并发编程之CountDownLatch

﹏ヽ暗。殇╰゛Y 2022-06-03 10:53 259阅读 0赞

> **java.util.concurrent.CountDownLatch**是jdk1.5引入的一种通过计数器的方式来实现多线程环境下等待指定操作完成的并发机制

### **CountDownLatch 可以通过构造函数指定计数器的初始值，即*countDown*原子方法调用次数，*countDown*每调用一次，计数器减一** ###

CountDownLatch latch = new CountDownLatch(3);

### **线程通过调用*CountDownLatch .await()*等待，直至计数器等于0** ###

CountDownLatch .await()

### **示例代码** ###

#### **创建多线程实例** ####

import java.util.concurrent.CountDownLatch;
    
    public class Processor implements Runnable { 
        private CountDownLatch latch;
        private int i;
    
        public Processor(CountDownLatch latch, int i) {
            this.latch = latch;
            this.i = i;
        }
    
        public void run() {
            System.out.println(String.format("Processor %s Started.", i));
    
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            latch.countDown();
        }
    }

#### **主线程await** ####

import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Driver {
    
        public static void main(String[] args) {
            CountDownLatch latch = new CountDownLatch(3); // coundown from 3 to 0
            ExecutorService executor = Executors.newFixedThreadPool(3); // 3 Threads in pool
            for (int i = 0; i < 3; i++) {
                executor.submit(new Processor(latch, (i + 1))); // ref to latch. each time call new Processes latch will count down by 1
            }
            try {
                latch.await();  // wait until latch counted down to 0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Completed.");
            executor.shutdown();
        }
    }

#### **执行结果** ####

> Processor 1 Started.  
> Processor 3 Started.  
> Processor 2 Started.  
> Completed.