JUC（7）同步控制(辅助类)

一、 CountDownLatch（倒计时器）

• 其实就是一个减法计数器，对于计数器归零之后再进行后面的操作，这是一个计数器！

package com.wlw.add;

import java.util.concurrent.CountDownLatch;

//减法计数器
//有必须要在一些任务完成之后才能执行的任务（注意顺序），再使用这个类
public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        /**
         * 案例： 教室里有6个学生，只有当6个学生全都走了，才能关门
         */
        CountDownLatch countDownLatch = new CountDownLatch(6); //总数为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(); //等待计数器归零，然后再往下走 （等待6个学生全都走了，再执关门，如果没这一句关门这个操作可能会在任意时候执行）

        System.out.println("Close Door");
    }
}

• 原理:
  • countDownLatch. countDown(); 数量-1
  • countDownLatch. await(); /等待计数器归零,然后再向下执行
  • 每次有线程调用countDown()数量-1 ,假设计数器变为0 , countDownLatch.await()就会被唤醒,继续执行!

二、CyclicBarrier（循环栅栏）

• 加法计数器

package com.wlw.add;

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

//加法计数器
public class CyclicBarrierDemo {

    public static void main(String[] args) {
        /**
         * 案例：集齐7颗龙珠，召唤神龙
         */
        //设定计数器要累计的条件，还有达到条件后要执行的任务
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, new Runnable() {
            @Override
            public void run() {
                System.out.println("召唤神龙，噢噢噢噢哦哦哦~~~~~~");
            }
        });

        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await(); // 等待计数器达到设定的条件，再执行后续操作 （即等待收集7颗龙珠后，才能召唤神龙）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

三、 Semaphore（信号量）

• Semaphore：信号量

package com.wlw.add;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        //案例：6辆车，只有3个车位 ，   Semaphore来定义线程数量（可用于限流）
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; 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();//释放许可证  （离开了 车位就要被释放）
                }
            },String.valueOf(i)).start();
        }
    }
}

• 原理：

  • semaphore.acquire()获得资源，如果资源已经使用完了，就等待资源释放后再进行使用！（信号量-1）
  • semaphore.release()释放，会将当前的信号量释放+1，然后唤醒等待的线程！

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

四、读写锁ReadWritelock（读写锁）

此部分可以参考https://blog.csdn.net/wang_luwei/article/details/107490047

• ReadWriteLock它只是一个接口， ReentrantReadWriteLock是ReadWriteLock的实现类
• Lock也是一个接口，它的实现类有ReentrantLock(最常用), ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock
• 互斥规则：
  • ReadwriteLock
    读-读 可以共存!
    读-写 不能共存!
    写-写 不能共存!
  • 独占锁(写锁) 一次只能被一个线程占有
  • 共享锁(读锁) 多个线程可以同时占有
• ReentrantReadWriteLock 中有两个方法：
  • writeLock() 获取到写锁 （writeLock()方法返回用于写入操作的锁。类型是ReentrantReadWriteLock.WriteLock，它实现了Lock接口）
  • readLock() 获取到读锁 （readLock()方法返回用于读取操作的锁。类型是ReentrantReadWriteLock.ReadLock，它实现了Lock接口）

package com.wlw.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        //MyCache myCache = new MyCache();
        MyCacheReadWriteLock myCache = new MyCacheReadWriteLock();

        //多个线程写入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            }).start();
        }

        //多个线程读取
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            }).start();
        }
    }
}

//我们想要实现 写入的时候只能一个线程同时写入，读取可以线程同时读取
//我们也可以采用synchronized这种重量锁和轻量锁 lock去保证数据的可靠。
//但是这次我们采用更细粒度的锁：ReadWriteLock 读写锁来保证
class MyCacheReadWriteLock {
    //读写锁 ReadWriteLock它只是一个接口， ReentrantReadWriteLock是ReadWriteLock的实现类
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock(); //这只是一个普通的锁

    private volatile Map<String,String> map=new HashMap<>();

    //写入 （这是一个原子操作）只希望同时只有一个线程写
    public void put(String key,String value){
        // readWriteLock.writeLock() 获取到写锁 （writeLock()方法返回用于写入操作的锁。类型是ReentrantReadWriteLock.WriteLock，它实现了Lock接口）
        //lock()  上锁
        readWriteLock.writeLock().lock();
        try {
            //写入
            System.out.println(Thread.currentThread().getName()+" 线程 开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()+" 线程 写入OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock(); //解锁
        }

    }

    //读取，所有都可以读
    public void get(String key) {
        // readWriteLock.readLock() 获取到读锁 （readLock()方法返回用于读取操作的锁。类型是ReentrantReadWriteLock.ReadLock，它实现了Lock接口）
        readWriteLock.readLock().lock(); //上锁
        try {
            //获取
            System.out.println(Thread.currentThread().getName() + " 线程 开始读取");
            String o = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 线程 读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();//解锁
        }

    }

}

//不加锁 ，多线程的读写会造成数据不可靠的问题。
class MyCache{
    private volatile Map<String,String> map=new HashMap<>();

    public void put(String key,String value){
        //写入
        System.out.println(Thread.currentThread().getName()+" 线程 开始写入");
        map.put(key, value);
        System.out.println(Thread.currentThread().getName()+" 线程 写入OK");
    }

    public void get(String key){
        //获取
        System.out.println(Thread.currentThread().getName()+" 线程 开始读取");
        String o = map.get(key);
        System.out.println(Thread.currentThread().getName()+" 线程 读取OK");

    }
}