并发包下锁的一些应用

前言：在并发中，最熟悉的JUC编程，问的最多的也是下面四个包，随手写篇博客记录日常中的学习一下！

 一、读写锁

java.util.concurrent.locks.ReentrantReadWriteLock;

　　ReadWriteLock管理一组锁，一个是只读的锁，一个是写锁。读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。
所有读写锁的实现必须确保写操作对读操作的内存影响。换句话说，一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容。
读写锁比互斥锁允许对于共享数据更大程度的并发。每次只能有一个写线程，但是同时可以有多个线程并发地读数据。ReadWriteLock适用于读多写少的并发情况。

　　举个例子，有六个线程进行读写操作，但是呢，我们在写入数据的时候是并不希望有别的线程来加塞，我们在读取的时候可以多个线程进行读取：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author zhangzhixi
 * @date 2021-4-18 22:25
 */
public class Demo_01_读写锁 {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        // 六个写的线程
        for (int i = 1; i <= 6; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        // 六个读的线程
        for (int i = 1; i <= 6; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}

/**
 * 定义缓存类
 */
class MyCache {
    volatile Map<String, Object> map = new HashMap<>();

    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + "	 正在写入" + key);
        // 模拟网络延迟
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "	 写入完成");
    }

    public void get(String key) {
            // 模拟网络延迟
            try {
                TimeUnit.MICROSECONDS.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object value = map.get(key);
            System.out.println(Thread.currentThread().getName() + "	 读取完成->" + value);
    }
}

通过上面的测试可以看到，线程在写入数据的时候，有其他线程过来加塞。

改进后的读写锁代码：

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author zhangzhixi
 * @date 2021-4-18 22:25
 */
public class Demo_01_读写锁 {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        // 六个写的线程
        for (int i = 1; i <= 6; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }
        // 六个读的线程
        for (int i = 1; i <= 6; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, String.valueOf(i)).start();
        }
    }
}

/**
 * 定义缓存类
 */
class MyCache {
    volatile Map<String, Object> map = new HashMap<>();
    ReadWriteLock lock = new ReentrantReadWriteLock();
    public void put(String key, String value) {
        // 写入数据
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "	 正在写入" + key);
            // 模拟网络延迟
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "	 写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "	 正在读取" + key);
            // 模拟网络延迟
            try {
                TimeUnit.MICROSECONDS.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object value = map.get(key);
            System.out.println(Thread.currentThread().getName() + "	 读取完成->" + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }
}

 二、倒计时锁存器：秦一统六国实例

java.util.concurrent.CountDownLatch;

　　CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，调用线程会被阻塞。
其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞),
当计数器的值变为零时，因调用await方法被阻塞的线程会被唤醒，继续执行。

　　例子：班级放学后班长最后一个走人，班长锁门

import java.util.concurrent.CountDownLatch;

/**
 * @author zhangzhixi
 * @date 2021-4-18 23:15
 */
public class Demo_02_倒计时锁存器 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "	 上完自习离开教室");
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("班长最后离开锁门~");
    }
}

---

CountDownLatch实例之枚举的应用

秦国一统天下，歼灭各国怎么用代码表示呢？

 下面使用的是枚举的方式定义线程的名称：

import java.util.concurrent.CountDownLatch;

/**
 * @author zhangzhixi
 * @date 2021-4-19 9:19
 */
public class Demo_03_倒计时锁存器之枚举的应用 {
    public static void main(String[] args) throws InterruptedException {
        // 倒计时计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                // 减少寄存器的数量
                countDownLatch.countDown();
                System.out.println(Thread.currentThread().getName() + "国,被灭了");
            }, CountEnum.forEachEnum(i).getName()).start();
        }

        // 导致当前线程等待，直到锁存器递减计数到零为止，除非该线程被中断
        countDownLatch.await();
        System.out.println("秦国一统天下~");
    }
}

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

    private Integer id;
    private String name;

    CountEnum(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public static CountEnum forEachEnum(int index) {
        // 以声明顺序返回包含此枚举类型的常量的数组
        CountEnum[] values = CountEnum.values();
        for (CountEnum element : values) {
            if (index == element.getId()) {
                return element;
            }
        }
        return null;
    }
}

 三、循环屏障：七龙珠实例

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

/**
 * @author zhangzhixi
 * @date 2021-4-19 22:28
 */
public class Demo_04_循环屏障之七龙珠 {
    public static void main(String[] args) {
        // 集齐七颗龙珠召唤神龙
        CyclicBarrier barrier = new CyclicBarrier(7, () -> {
            System.out.println("=========收集到了神龙===========");
        });
        for (int i = 1; i <= 7; i++) {
            final int emp = i;
            new Thread(() -> {
                System.out.println("集齐到了第" + emp + "颗龙珠");
                try {
                    // 等到所有各方都在此障碍上调用await 
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }

    }
}

 四、信号灯Semaphore：抢车位实例

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

/**
 * @author zhangzhixi
 * @date 2021-4-19 22:38
 */
public class Demo05_信号量_抢车位 {
    public static void main(String[] args) {
        // 给了三个车位
        Semaphore semaphore = new Semaphore(3);

        // 模拟6个车子
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                // 抢到车位(抢占)
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "	 号车子抢到抢到了");
                    // 模拟停车时间
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "	 号车子停车2S后离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 车子离开车位，
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}