CountDownLatch

// 计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 总数是6，必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " Go out");
                countDownLatch.countDown(); // -1
            }, String.valueOf(i)).start();
        }

        countDownLatch.await(); // 等待计数器归零，然后再向下执行

        System.out.println("Close door");

    }
}

原理： ountDownLatch.countDown(); // 数量-1

countDownLatch.await(); // 等待计数器归零，然后再向下执行

每次有线程调用 countDown() 数量-1，假设计数器变为0，countDownLatch.await() 就会被唤醒，继续执行！

CycliBarrier

加法计数器

package com.mystpet.CountDownDemo;  
  
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
  
public class CyclicBarrierDemo {  
    public static void main(String[] args) {  
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {  
            System.out.println("召唤神龙成功");  
        });  
  
        for (int i = 0; i <= 6; i++) {  
// lambda表达式能操作变量i吗？ 不能，必须要用final定义一个临时变量  
          final int temp=i;  
            new Thread(() -> {  
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"龙珠");  
  
                try {  
                    cyclicBarrier.await();  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                } catch (BrokenBarrierException e) {  
                    throw new RuntimeException(e);  
                }  
            }).start();  
        }  
    }  
}

结果：

Semaphore

Semaphore:信号量

抢车位！

6车—3个停车位置

package com.mystpet.CountDownDemo;  
  
import java.sql.Time;  
import java.util.concurrent.Semaphore;  
import java.util.concurrent.TimeUnit;  
  
public class SemaphoreDemo {  
    public static void main(String[] args) {  
  
        // 构造参数 默认线程数量：类似停车位  用来限流  
 Semaphore semaphore = new Semaphore(3);  
        for (int i = 0; i < 6; i++) {  
           new Thread(() -> {  
  
               // acquire() 得到  
               // release() 释放  
  
               try {  
                   semaphore.acquire();  
                   System.out.println(Thread.currentThread().getName() + "抢到车位");  
                   TimeUnit.SECONDS.sleep(4);  
                   System.out.println(Thread.currentThread().getName() + "离开车位");  
               } catch (InterruptedException e) {  
                   throw new RuntimeException(e);  
               } finally {  
                   semaphore.release();  
               }  
           },String.valueOf(i)).start();  
        }  
  
    }  
}

运行结果：线程释放完后其他线程才能进入

原理：

semaphore.acquire() 获得，假设如果已经满了，等待，等待被释放为止！

semaphore.release(); 释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！

作用： 多个共享资源互斥的使用！并发限流，控制最大的线程数！