JUC高并发编程8：读写锁

1 概述

1.1 悲观锁和乐观锁

在并发编程中，锁机制是用来控制多个线程对共享资源的访问。悲观锁和乐观锁是两种不同的并发控制策略。

1.1.1 悲观锁（Pessimistic Locking）

悲观锁假设在最坏的情况下，多个线程会同时访问和修改共享资源，因此在访问共享资源之前，会先对资源进行加锁，以确保同一时间只有一个线程可以访问该资源。常见的悲观锁实现包括数据库中的表锁和行锁。

优点：可以有效避免数据冲突，适用于写操作较多的场景。
缺点：加锁和解锁操作会增加系统开销，可能导致性能下降。

1.1.2 乐观锁（Optimistic Locking）

乐观锁假设在大多数情况下，多个线程不会同时访问和修改共享资源，因此在访问共享资源时不会立即加锁，而是在提交修改时检查资源是否被其他线程修改过。如果资源被修改过，则回滚操作或重试。常见的乐观锁实现包括版本号机制和时间戳机制。

优点：减少了加锁和解锁的开销，适用于读操作较多的场景。
缺点：在并发冲突较多的情况下，可能会导致频繁的重试操作，影响性能。

1.2 表锁和行锁

在数据库中，锁机制用于控制对表或行的访问。

1.2.1 表锁（Table Lock）

表锁是对整个表进行加锁，当一个事务对表进行加锁后，其他事务无法对该表进行写操作，但可以进行读操作（取决于锁的类型）。

优点：实现简单，不会发生死锁。
缺点：锁的粒度较大，可能会影响并发性能。

1.2.2 行锁（Row Lock）

行锁是对表中的某一行进行加锁，当一个事务对某一行进行加锁后，其他事务无法对该行进行写操作，但可以对其他行进行操作。

优点：锁的粒度较小，可以提高并发性能。
缺点：实现复杂，可能会发生死锁。

1.3 读锁和写锁

在数据库中，锁可以分为读锁和写锁。

1.3.1 读锁（Read Lock）

读锁是一种共享锁（Shared Lock），多个事务可以同时持有读锁，但持有读锁的事务不能进行写操作。读锁不会阻塞其他读锁，但会阻塞写锁。

优点：允许多个事务同时读取数据，提高了并发性能。
缺点：可能会发生死锁，特别是在多个事务同时持有读锁并等待写锁时。

1.3.2 写锁（Write Lock）

写锁是一种独占锁（Exclusive Lock），当一个事务持有写锁时，其他事务不能持有任何锁（包括读锁和写锁）。写锁会阻塞其他所有锁。

优点：可以确保数据的一致性，避免数据冲突。
缺点：可能会发生死锁，特别是在多个事务同时持有写锁并等待其他锁时。

1.4 死锁

死锁是指两个或多个事务在等待对方释放锁的情况下，都无法继续执行的状态。死锁通常发生在以下情况：

读锁和写锁的相互等待：例如，事务1持有读锁并等待事务2释放写锁，而事务2持有写锁并等待事务1释放读锁。
行锁的相互等待：例如，事务1锁定了某一行并等待事务2释放另一行的锁，而事务2锁定了另一行并等待事务1释放第一行的锁。

1.5 小结

悲观锁：适用于写操作较多的场景，通过加锁避免数据冲突，但会增加系统开销。
乐观锁：适用于读操作较多的场景，通过版本号或时间戳机制避免数据冲突，减少加锁开销，但在并发冲突较多时可能导致频繁重试。
表锁：对整个表加锁，实现简单，不会发生死锁，但锁粒度大，影响并发性能。
行锁：对表中的某一行加锁，锁粒度小，提高并发性能，但可能发生死锁。
读锁：允许多个事务同时读取数据，提高并发性能，但可能发生死锁。
写锁：确保数据一致性，避免数据冲突，但可能发生死锁。

2 案例实现

场景: 使用 ReentrantReadWriteLock 对一个 hashmap 进行读和写操作

代码

//资源类
class MyCache{

    // 创建map集合
    private volatile Map<String,Object> map = new HashMap<>();

    // 创建读写锁对象
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    // 放数据
    public void put(String key,Object value){
        // 添加写锁
        rwLock.writeLock().lock();




        try {
            System.out.println(Thread.currentThread().getName() +" 正在写操作"+key);
            // 暂停一会儿
            TimeUnit.MICROSECONDS.sleep(300);

            // 放数据
            map.put(key,value);

            System.out.println(Thread.currentThread().getName()+" 写完了" + key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放写锁
            rwLock.writeLock().unlock();
        }


    }

    // 取数据
    public Object get(String key){
        // 添加读锁
        rwLock.readLock().lock();
        Object result = null;

        try {

            System.out.println(Thread.currentThread().getName() + " 正在读取操作" + key);
            // 暂停一会儿
            TimeUnit.MICROSECONDS.sleep(300);

            result = map.get(key);
            System.out.println(Thread.currentThread().getName()+" 取完了" + key);

        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放读锁
            rwLock.readLock().unlock();
        }
        return result;

    }
}
public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
        // 创建线程放数据
        for (int i = 0; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.put(num+"",num+"");

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

        TimeUnit.MICROSECONDS.sleep(300);

        // 创建线程取数据
        for (int i = 0; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.get(num+"");

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

3 读写锁的演变

3.1 读写锁（Read-Write Lock）

读写锁是一种特殊的锁机制，它允许多个读线程同时访问共享资源，但只允许一个写线程访问共享资源。读写锁的主要目的是提高并发性能，特别是在读操作远多于写操作的场景中。

3.1.1 读写锁的特点

读读共享：多个读线程可以同时持有读锁，读操作之间不会互斥。
读写互斥：当一个写线程持有写锁时，其他读线程和写线程都不能访问共享资源。
写写互斥：当一个写线程持有写锁时，其他写线程不能访问共享资源。

3.2 读写锁的演变

3.2.1 无锁

在无锁的情况下，多个线程可以同时访问共享资源，这会导致资源竞争和数据不一致的问题。

public class NoLockExample {
    private int resource = 0;

    public void read() {
        System.out.println("Read: " + resource);
    }

    public void write(int value) {
        resource = value;
        System.out.println("Write: " + resource);
    }
}

3.2.2 添加锁

使用 synchronized 或 ReentrantLock 可以解决资源竞争的问题，但这些锁是独占的，每次只能有一个线程操作资源，即使是读操作也不能共享。

public class SynchronizedLockExample {
    private int resource = 0;

    public synchronized void read() {
        System.out.println("Read: " + resource);
    }

    public synchronized void write(int value) {
        resource = value;
        System.out.println("Write: " + resource);
    }
}

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

public class ReentrantLockExample {
    private int resource = 0;
    private Lock lock = new ReentrantLock();

    public void read() {
        lock.lock();
        try {
            System.out.println("Read: " + resource);
        } finally {
            lock.unlock();
        }
    }

    public void write(int value) {
        lock.lock();
        try {
            resource = value;
            System.out.println("Write: " + resource);
        } finally {
            lock.unlock();
        }
    }
}

3.2.3 读写锁

使用 ReentrantReadWriteLock 可以实现读读共享，提高并发性能。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int resource = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void read() {
        rwLock.readLock().lock();
        try {
            System.out.println("Read: " + resource);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void write(int value) {
        rwLock.writeLock().lock();
        try {
            resource = value;
            System.out.println("Write: " + resource);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

3.2.3.1 读写锁的缺点

锁饥饿：如果读操作非常频繁，写操作可能会长时间等待，导致写线程饥饿。例如，在地铁系统中，如果一直有人在读取信息（如查看列车时刻表），而没有人进行写操作（如更新列车状态），写操作可能会被长时间阻塞。
读写互斥：读操作在进行时，写操作不能进行，只有读操作完成后，写操作才能进行。这可能会导致写操作的延迟。
写读互斥：写操作在进行时，读操作不能进行，只有写操作完成后，读操作才能进行。这可能会导致读操作的延迟。

4 读写锁的降级

读写锁的降级是指在持有写锁的情况下，获取读锁，然后释放写锁，最后释放读锁的过程。这种操作通常用于在写操作完成后，需要进行读操作的场景。通过锁降级，可以在保证数据一致性的前提下，提高并发性能。

4.1 JDK 8 中的锁降级说明

在 JDK 8 中，读写锁的降级操作可以按照以下步骤进行：

获取写锁：首先获取写锁，确保当前线程对共享资源有独占访问权限。
获取读锁：在持有写锁的情况下，获取读锁。
释放写锁：释放写锁，此时其他线程可以获取写锁，但当前线程仍然持有读锁。
释放读锁：最后释放读锁，完成整个锁降级过程。

4.2 示例代码

以下是一个使用 ReentrantReadWriteLock 进行锁降级的示例代码：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDowngradeExample {
    private int resource = 0;
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void downgradeLock() {
        rwLock.writeLock().lock(); // 获取写锁
        try {
            // 写操作
            resource = 100;
            System.out.println("Write: " + resource);

            rwLock.readLock().lock(); // 获取读锁
        } finally {
            rwLock.writeLock().unlock(); // 释放写锁
        }

        try {
            // 读操作
            System.out.println("Read: " + resource);
        } finally {
            rwLock.readLock().unlock(); // 释放读锁
        }
    }

    public static void main(String[] args) {
        ReadWriteLockDowngradeExample example = new ReadWriteLockDowngradeExample();
        example.downgradeLock();
    }
}