Java_JUC_CountDownLatch/CyclicBarrier循环屏障/Semaphore信号灯/枚举

Java_JUC_CountDownLatch/CyclicBarrier循环屏障/Semaphore信号灯/枚举

java常用的juc api

（一）枚举

1.1 代码实现

package jucapi;

import lombok.Getter;

/**
 * 枚举 就是一张数据库的表
 * 用了枚举可以降低程序的耦合度
 *
 * 主要是给CountDownLatchDemo用的
 */

public enum CountryEnum{
    ONE(1,"齐"), TWO(2,"楚"), THREE(3,"燕"), FOUR(4,"赵"), FIVE(5,"魏"), SIX(6,"韩");

    @Getter private Integer retCode;   //1
    @Getter private String retMessage; //齐
    @Getter private String retMessage2;

    CountryEnum(Integer retCode, String retMessage) {
        this.retCode = retCode;
        this.retMessage = retMessage;
    }


    /**
     * CountDownLatchDemo 调用的方法
     * @param index 1
     * @return 齐
     */
    public static CountryEnum forEach_CountryEnum(int index){
        //变数组
        CountryEnum[] myArray = CountryEnum.values();
        //增强for循环
        //如果CountDownLatchDemo传过来的index是1，那么我返回“齐”
        for(CountryEnum element:myArray){
            if(index == element.getRetCode()){
                return element;
            }
        }
        return null;
    }


    /**
     * get set
     * @return
     */
    public Integer getRetCode() {
        return retCode;
    }

    public void setRetCode(Integer retCode) {
        this.retCode = retCode;
    }

    public String getRetMessage() {
        return retMessage;
    }

    public void setRetMessage(String retMessage) {
        this.retMessage = retMessage;
    }

}

/**
 mysql daNmae = CountryEnum

 table
 one
 ID userName age birth userEmail
 1  齐       109

   ONE(1,"齐",v2,v3,v4,v5)
 */

（二）CountDownLatch

2.1 什么是CountDownLatch？

让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。

2.2 方法

• //大招step1
  CountDownLatch countDownLatch = new CountDownLatch(6);
• //大招step2
  countDownLatch.countDown();
• //大招step3
  countDownLatch.await();

一个或多个调用await方法的线程会被阻塞，

其它线程调用countDown方法会将计数器减1（该线程不会阻塞），

当计数器的值变为0时，因调用await方法被阻塞的线程会被唤醒，继续执行。

2.3 代码实现

package jucapi;

import java.util.concurrent.CountDownLatch;

/**
 * java 常用的JUC api
 * CountDownLatch
 
 先看 closeDoor()
 *
 * 用了枚举可以降低程序的耦合度
 *
 * 需要用到自写的一个枚举
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {

        //大招step1
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for(int i=1;i<=6;i++){
            //哪个线程用枚举
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t国被灭");
                //大招step2 计数减1
                countDownLatch.countDown();
            },CountryEnum.forEach_CountryEnum(i).getRetMessage()).start();  //线程名字调用了枚举
        }

        //大招step3
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t--------秦，一统华夏");
        System.out.println(CountryEnum.ONE);
        System.out.println(CountryEnum.ONE.getRetCode());
        System.out.println(CountryEnum.ONE.getRetMessage());

    }


    /**
     * CountDownLatch
     * 用于理解的最简单的例子
     * @throws InterruptedException
     */
    public static void closeDoor() throws InterruptedException {
        //大招step1
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i=1;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t上完晚自习，走人");
                //大招step2
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        //大招step3
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"\t班长关门走人");
    }


}

/*
赵	国被灭
韩	国被灭
燕	国被灭
魏	国被灭
齐	国被灭
楚	国被灭
main	--------秦，一统天下
ONE
1
齐

 */

（三）CyclicBarrier循环屏障

3.1 什么是CyclicBarrier？

做加法：集齐七龙珠，才能召唤神龙。

3.2 方法

• //大招step1
  CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{ System.out.println(“***********召唤神龙”); });

• //大招step2 先来的等待

​ cyclicBarrier.await();

3.3 代码实现

package jucapi;

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

/**
 * CyclicBarrier
 * 翻译：循环屏障
 *
 * 集齐七龙珠，才能召唤神龙
 * 先到的线程，先等着
 */

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

        //大招step1
        //CyclicBarrier(int parties, Runnable barrierAction)
        //注 Runnable接口的最好用lambda表达式
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{ System.out.println("***********召唤神龙"); }); //必须要有接收

        for(int i=1;i<=7;i++) {
            final int tempInt = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"\t收到第："+tempInt+"颗龙珠");

                //大招step2 先来的等待
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            },String.valueOf(i)).start();
        }

    }

}

/*
1	收到第：1颗龙珠
5	收到第：5颗龙珠
3	收到第：3颗龙珠
6	收到第：6颗龙珠
7	收到第：7颗龙珠
2	收到第：2颗龙珠
4	收到第：4颗龙珠
***********召唤神龙
 */

（四）Semaphore信号灯

4.1 什么是Semaphore？

6辆车枪3个车位，直到6辆车都停过3秒为止，多个线程抢占多份资源

4.2 方法

• //大招step1 模拟三个车位
  Semaphore semaphore = new Semaphore(3);

• //大招step2 线程去获得车位
  semaphore.acquire();

• //大招step3 线程3后去释放车位
  semaphore.release();

4.3 代码实现

package jucapi;

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

/**
 * SemaphoreDemo 信号灯
 * 解释：6辆车枪3个车位，直到6辆车都停过3秒为止，多个线程抢占多份资源
 *
 * 有减有增，有增有减
 *
 * 用好了完全可以代替synchronize锁等
 *
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        //大招step1 模拟三个车位
        Semaphore semaphore = new Semaphore(3);

        for(int i=1;i<=6;i++) {
            new Thread(() -> {
                try {
                    //大招step2 线程去获得车位
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t获得车位");
                    //休眠3秒
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"\t停车3秒后离开车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //大招step3 线程去释放车位
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }


}

/*
1	获得车位
5	获得车位
2	获得车位
5	停车3秒后离开车位
1	停车3秒后离开车位
6	获得车位
2	停车3秒后离开车位
3	获得车位
4	获得车位
4	停车3秒后离开车位
3	停车3秒后离开车位
6	停车3秒后离开车位
 */

如果你发现