java锁： ReadWriteLock 和 StampedLock的对比

小咪咪 2024-02-20 12:17 22阅读 0赞

>  *  ReadWriteLock 并发读多写少，为了控制并发操作的粒度，Java提供了读写锁。读操作之间不需要互斥，遇到写的时候会互斥。
>  *  StampedLock ReadWriteLock实际用的时候表现不尽如人意，主要还是因为相对比较大的开销。所以引入了StampedLock，引入优化读模式。
>     
>     优化读基于假设，大多数情况下读操作并不会和写操作冲突，其逻辑是先试着修改，然后通过validate方法确认是否进入了写模式，如果没有进入，就成功避免了开销；如果进入，则尝试获取读锁。

## 特点对比 ##

ReadWriteLock 和 StampedLock 是 Java 并发包提供的两种高级锁机制，用于在多线程环境下实现读写分离的访问控制。它们在某些场景下可以比传统的锁机制（如 ReentrantLock）提供更高的并发性和性能。

1.  ReadWriteLock：  
    ReadWriteLock 接口定义了读写锁的基本操作，包括获取读锁、释放读锁、获取写锁和释放写锁。与传统的独占锁不同，读写锁允许多个线程同时获取读锁，但在写锁被获取时，所有的读锁和其他写锁都会被阻塞。
    
    读写锁适用于读多写少的场景，可以提高并发性。多个线程可以同时获取读锁，读操作可以并发进行，而写操作会独占资源，要求独占写锁。
2.  StampedLock：  
    StampedLock 是 Java 8 引入的一种乐观读锁机制。它允许多个线程同时读取共享资源，但在写锁被获取时，所有的读锁和写锁都会被阻塞。与 ReadWriteLock 不同的是，StampedLock 还引入了乐观读模式。
    
    乐观读模式允许读取操作无需获取读锁，而是返回一个 stamp（标记），然后进行读操作。如果在读操作期间没有发生写操作，读操作就成功了。如果读操作期间发生了写操作，读操作可能失败。在乐观读失败后，可以选择获取读锁以重试或者获取写锁。
    
    StampedLock 适用于读操作非常频繁，而写操作较少发生的场景。通过乐观读模式的引入，减少了对写锁的竞争，提高了并发性能。

下面是对比 ReadWriteLock 和 StampedLock 的特点：

*  读写锁特点：
    
     *  读操作可以并发进行，提高读并发性。
     *  写操作会独占资源，要求独占写锁。
     *  读锁与写锁互斥，写锁优先级高于读锁。
 *  StampedLock 特点：
    
     *  引入了乐观读模式，允许读操作无需获取读锁进行读取，提高读并发性。
     *  写操作会独占资源，要求独占写锁。
     *  乐观读模式下，读操作可能失败，需要处理读失败的情况。

需要注意的是，StampedLock 的使用需要更加谨慎，因为在乐观读模式下，读操作可能失败。如果读操作的结果对后续的业务逻辑非常重要，可能需要使用悲观读模式（即获取读锁）来确保操作的正确性。

总结：  
ReadWriteLock 和 StampedLock 都提供了读写分离的访问控制，允许多个线程同时进行读操作，但在写操作时需要独占资源。ReadWriteLock 适用于读多写少的场景，StampedLock 在此基础上引入了乐观读模式，适用于读操作非常频繁的场景。在选择使用哪种锁机制时，需要根据具体的并发需求和场景综合考虑。

## 代码演示 ##

下面是使用 ReadWriteLock 和 StampedLock 的代码示例：

1.  使用 ReadWriteLock 的示例代码：

import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class ReadWriteLockExample {
        
        private int value = 0;
        private ReadWriteLock lock = new ReentrantReadWriteLock();
    
        public int getValue() {
        
            lock.readLock().lock();
            try {
        
                return value;
            } finally {
        
                lock.readLock().unlock();
            }
        }
    
        public void increment() {
        
            lock.writeLock().lock();
            try {
        
                value++;
            } finally {
        
                lock.writeLock().unlock();
            }
        }
    }

在上述代码中，`ReadWriteLockExample` 类使用了 `ReentrantReadWriteLock` 实现读写锁。`getValue()` 方法使用读锁来读取 `value` 值，`increment()` 方法使用写锁来递增 `value` 值。多个线程可以同时获取读锁进行读取操作，但在写锁被获取时，所有的读锁和其他写锁都会被阻塞。

1.  使用 StampedLock 的示例代码：

import java.util.concurrent.locks.StampedLock;
    
    public class StampedLockExample {
        
        private int value = 0;
        private StampedLock lock = new StampedLock();
    
        public int getValue() {
        
            long stamp = lock.tryOptimisticRead();
            int currentValue = value;
            if (!lock.validate(stamp)) {
        
                stamp = lock.readLock();
                try {
        
                    currentValue = value;
                } finally {
        
                    lock.unlockRead(stamp);
                }
            }
            return currentValue;
        }
    
        public void increment() {
        
            long stamp = lock.writeLock();
            try {
        
                value++;
            } finally {
        
                lock.unlockWrite(stamp);
            }
        }
    }

在上述代码中，`StampedLockExample` 类使用了 `StampedLock` 实现读写锁。`getValue()` 方法首先尝试使用乐观读模式来读取 `value` 值，如果乐观读失败，则使用悲观读模式来获取读锁，再次读取 `value` 值。`increment()` 方法使用写锁来递增 `value` 值。乐观读模式下的读操作可能失败，需要根据失败情况采取相应的措施。