读写锁ReadWriteLock

ReadWriteLock是JDK5.0新增的一个类，它可以实现读写分离锁. 读写分离锁可以有效的减少锁的竞争,提升系统性能。用锁分离的机制来提升性能非常容易理解，比如线程A1、A2、A3进行写操作，B1、B2、B3进行读操作，如果使用重入锁或者内部锁，从理论上说所有读之间、读与写之间、写和写之间都是串行操作。当B1进行读取时，B2、B3则需要等待锁。由于读操作并不对数据的完整性造成破坏，这种等待显然是不合理的。因此，读写锁就有了发挥功能的余地。
在这种情况下，读写锁允许多个线程同时读，使得B1、B2、B3之间真正并行。但是，考虑到数据完整性，写写操作和读写操作间依然是需要相互等待和持有锁的。总的来说，读写锁的访问约束情况如下图:

• 读-读不互斥：读读之间不阻塞。
• 读-写互斥：读阻塞写，写也会阻塞读。
• 写-写互斥：写写阻塞。

如果在系统中，读操作的次数远远大于写操作的次数，则读写锁就可以发挥最大的功效，提升系统的性能。这里我给出一个稍微夸张点的案例来说明读写锁对性能的帮助。

package com.example.demo.hmjuc.day12;

import com.example.demo.hmjuc.Sleep;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁ReadWriteLock
 * ReadWriteLock是JDK5.0新增的一个类，它可以实现读写分离锁. 读写分离锁可以有效的减少锁的竞争,
 * 提升系统性能。用锁分离的机制来提升性能非常容易理解，比如线程A1、A2、A3进行写
 * 操作，B1、B2、B3进行读操作，如果使用重入锁或者内部锁，从理论上说所有读之间、读
 * 与写之间、写和写之间都是串行操作。当B1进行读取时，B2、B3则需要等待锁。由于读
 * 操作并不对数据的完整性造成破坏，这种等待显然是不合理的。因此，读写锁就有了发挥
 * 功能的余地。
 * 在这种情况下，读写锁允许多个线程同时读，使得B1、B2、B3之间真正并行。但是，
 * 考虑到数据完整性，写写操作和读写操作间依然是需要相互等待和持有锁的。总的来说，
 * 读写锁的访问约束情况如下图:
 * <p>
 * 读-读不互斥：读读之间不阻塞。
 * 读-写互斥：读阻塞写，写也会阻塞读。
 * 写-写互斥：写写阻塞。
 * <p>
 * 如果在系统中，读操作的次数远远大于写操作的次数，则读写锁就可以发挥最大的功
 * 效，提升系统的性能。这里我给出一个稍微夸张点的案例来说明读写锁对性能的帮助。
 *
 * @author zhangqi
 * @date 2022/5/12 14:54
 */
public class ReadWriteLockTest {
    private static final Lock LOCK = new ReentrantLock();
    private static final ReentrantReadWriteLock RW_LOCK = new ReentrantReadWriteLock();
    private static final Lock READ_LOCK = RW_LOCK.readLock();
    private static final Lock WRITE_LOCK = RW_LOCK.writeLock();

    private int value;


    public int handleRead(Lock lock) {
        lock.lock();
        try {
            Sleep.sleep(1000);
            return value;
        } finally {
            lock.unlock();
        }
    }

    public void handleWrite(Lock lock) {
        lock.lock();
        try {
            Sleep.sleep(1000);
            value++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteLockTest test = new ReadWriteLockTest();
        Runnable runnable1 = () -> {
            int i = test.handleRead(LOCK);
            System.out.println("i = " + i);
        };
        Runnable runnable2 = () -> test.handleWrite(LOCK);

        for (int i = 0; i < 18; i++) {
            new Thread(runnable1).start();
        }
        for (int i = 18; i < 20; i++) {
            new Thread(runnable2).start();
        }


    }


}