高并发--并发编程的三大辅助类

高并发---3个辅助类

在并发编程中用到，分别为：countdownlatch,cyclicbarrier,semaphore，三者其实都起到互斥的效果

Countdownlatch：减一操作，直到为0再继续向下执行

package Kuangshen.JUC.Thread;

import java.util.concurrent.CountDownLatch;

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

        final CountDownLatch countDownLatch = new CountDownLatch(5);

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "get out");
                countDownLatch.countDown();
                }, String.valueOf(i)).start();
        }
        countDownLatch.await(); //等待上述执行完毕再向下执行
        System.out.println("close door");
    }
}

Cyclicbarrier：+1操作，对于每个线程都自动+1并等待，累计到规定值再向下执行，

package Kuangshen.JUC.Thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author ：Empirefree
 * @description：TODO
 * @date ：2021/2/10 10:56
 */
public class cyclicbarrier {
    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        //CyclicBarrier里面是容量 + runnable
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () ->{
            System.out.println("不断增加到7即向后执行，与countdownlatch相反");
        }
       );

        /*对于指派的局部变量,lambda只能捕获一次 ，故而需定义成final(int内部定义就是final),而且线程中，
        不能对局部变量进行修改，如需要修改，需定义成原子类atomic
        */
        for (int i = 0; i < 7; i++) {
            int finalI = i;
            new Thread(() ->{
                System.out.println(finalI);
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            }).start();
        }
    }

}

semaphore：对于规定的值，多个线程只规定有指定的值能获取，每次获取都需要最终释放，保证一定能互斥执行

package Kuangshen.JUC.Thread;

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

/**
 * @author ：Empirefree
 * @description：TODO
 * @date ：2021/2/10 15:24
 */
public class semaphore {
    public static void main(String[] args) {
        final Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 60; i++) {
            new Thread(() -> {
                try {
                    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();
                }
            }).start();
        }
    }
}