JAVA高并发（JUC）之JUC工具类使用

话不多说，直接上代码：
第一个工具类CountDownLatch：
CountDownLatch： CountDownLatch主要有两个方法,当一个或多个线程调用await方法，这写线程会阻塞。其他线程调用CountDownLatch方法会将计数器减1（调用CountDownLatch方法的线程不会阻塞）当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
先举个例子对比一下：10个人都得出门后再进行锁门的操作


    public static void main(String[] args) {
     		        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "出来了");
            }, String.valueOf(i)).start();
        }
        System.out.println("锁门");   
    }        
//        0出来了
//        锁门
//        3出来了
//        2出来了
//        1出来了
//        5出来了
//        6出来了
//        4出来了
//        8出来了
//        7出来了
//        9出来了

显然我们无法做到我们怎么能确定当10个人都出来后在进行锁门操作呢？
这时候就可以用到我们的第一个工具类CountDownLatch
代码如下：

CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "出来了");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();  //减到0才继续
        System.out.println("锁门");
        
//        0出来了
//        3出来了
//        1出来了
//        2出来了
//        4出来了
//        5出来了
//        7出来了
//        6出来了
//        8出来了
//        9出来了
//        锁门

如果未减到0，那么会一直阻塞在这里！

第二个工具类CyclicBarrier：
CyclicBarrier类似于第一个，我们可以看看他的构造器：

CyclicBarrier(int parties, Runnable barrierAction) 
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。

接下来上代码。

    public static void main(String[] args) {
         CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> {
            System.out.println("锁门");
        });
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "第" + finalI + "出门");
                try {
                    cyclicBarrier.await();
                    System.out.println(finalI);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }

结果如下：
在这里插入图片描述
我们可以发现所有线程都通过await( )方法阻塞在了这里，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。

第三个工具类Semaphore：
想象一个抢车位的场景，如果车位有3个，6台车来抢车位，代码如下：

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore= new Semaphore(3);//模拟资源类，有3个空车位  为1的时候相当于synchronized
        for(int i=0;i<6;i++){
            new Thread(()->{
                try {
                    semaphore.acquire(); //占用
                    System.out.println(Thread.currentThread().getName()+"\t抢占到了车位");
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName()+"\t离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();//交还车位
                }
            },String.valueOf(i)).start();
        }
    }
}

执行结果如下：
在这里插入图片描述
在信号量上我们定义两种操作：

acquire（获取）当一个线程调用acquire操作时，它要通过成功获取信号量（信号量减1），要么一直等下去，知道有线程
释放信号量，或唤醒
release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
信号量主要用于两个目的，一个适用于多个共享资源的互斥使用，另一个适用于并发线程数的控制

JAVA高并发（JUC）之JUC工具类使用

猜你喜欢