小白的JUC学习08_读写锁

读写锁ReadWriteLock

---

一、ReadWriteLock介绍

ReadWriteLock是一个接口也位于java.util.concurrent.locks包下

真正实现为ReentrantReadWriteLock类，该类在内部提供了两个内部类读写类

读写分离：

• 可以有多个线程同时进行读取
• 写数据时，只有一个线程能获取锁，其他线程只能排队

二、使用

分别创建读写锁，应用到对应地方即可

• 记得解锁
• 读过程中也要加锁的原因是：
• 为了防止写的过程中，也进行读取，否则如果写的过程回滚了，那问题就大了

写锁也叫独占锁（排它锁）
读锁叫做共享锁【这些内容后面再阐释】

package com.migu;

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

public class Test {

    public static void main(String[] args) {
        MyCaChe caChe = new MyCaChe();

        for (int i = 1; i <= 150; i++) {
            final int temp = i;
            new Thread(()->{
                caChe.put(String.valueOf(temp),String.valueOf(temp));
                caChe.get(String.valueOf(temp));
            }).start();
        }
    }
}
// 同一块内存区域，要对他进行访问操作
class MyCaChe {
    private volatile Map map = new HashMap();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock writeLock = readWriteLock.writeLock();
    private Lock readLock = readWriteLock.readLock();
    public void put(String key,String value) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入: " + key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写入: ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }
    public void get(String key) {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取: " + map.get(key));
            System.out.println(Thread.currentThread().getName() + "读取: ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
}

输出：

写入操作必须完毕，才会执行其他操作，对于读取的话可以同时执行（此时输出并没有详细展示）