JUC学习笔记

CountDownLatch

减法计数器，达到一个初始化的值以后，才会执行接下来的操作

package cn.cy.test;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) {

        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i=1;i<=6;i++){
          final int  t = i;  //lambda 表达式里面的变量必须是常量,用final修饰
            new Thread(()->{
                System.out.println("haha"+t);
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }
        try {
            countDownLatch.await();//等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //如果循环次数小于6，也就是计数不到6，则会一直处于等待状态，不会向下执行
        //如果上面的循环次数超过6次，那么执行完6次以后，以下的操作就可能被执行了，不
        // 过具体次序还是无法具体确定，还得看线程是否抢得CPU的执行权
        System.out.println("轮到我了");
    }
}

CyclicBarrier

加法计数器，达到初始化的值以后，才会执行以下操作

package cn.cy.test;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐了7颗龙珠");
        });
        for(int i=1;i<=7;i++){
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"集齐了第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

Semaphore 信号量

多个线程，抢夺有限数量的资源，只有等资源被释放，才会有线程进入，否则处于阻塞等待状态

package cn.cy.test;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);  //3个停车位
        //6部车，3个停车位
        for(int i=1;i<=6;i++){
            new Thread(()->{
                try {
                    TimeUnit.SECONDS.sleep(2);
                    semaphore.acquire();//获取
                    System.out.println(Thread.currentThread().getName()+"停进车位了");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"出停车场了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();//释放
                }
            },String.valueOf(i)).start();
        }
    }
}