Java 多线程之 StampedLock(读写锁/乐观读锁/共享锁/排他锁)

文章目录

    • 一、概述
    • 二、使用方法
    • 三、测试示例

一、概述

  • StampedLock是Java 8引入的一种读写锁的实现,它提供了一种乐观的读锁(Optimistic Read Lock)和悲观的读锁(Pessimistic Read Lock),和写锁(Write Lock),以及对读-写冲突的解决方案。StampedLock的设计目标是在读多写少的场景下提供更高的并发性能。与传统的读写锁相比,StampedLock更加灵活和高效。

  • StampedLock 的主要功能如下:

    • 乐观读取(Optimistic Reading):通过调用 tryOptimisticRead() 方法获取一个乐观读锁的标记(stamp),该标记可以用于后续的读操作。乐观读锁不会阻塞写操作,即使其他线程在你获取锁之后进行了写操作,你的读操作仍然可以继续进行。但需要注意的是,乐观读锁并不能保证数据的一致性,因此在使用乐观读锁后,需要进一步验证数据的有效性。

    • 悲观读锁(Pessimistic Read Lock):通过调用 readLock() 方法获取一个悲观读锁,该锁会阻塞其他线程的写操作,保证了数据的一致性。在获取悲观读锁后,可以执行读操作,并且允许其他线程同时获取乐观读锁。

    • 写锁(Write Lock):通过调用 writeLock() 方法获取一个写锁,该锁会阻塞其他线程的读和写操作,保证了数据的一致性。在获取写锁后,可以执行写操作,期间不允许其他线程获取读锁或写锁。

    • 写锁和读锁的分离:在传统的读写锁中,写锁的获取会阻塞其他线程的读取和写入操作。而StampedLock将读锁和写锁分离,使得读锁之间不会互相阻塞,提高了并发读取的效率。

    • 读写冲突解决:StampedLock使用类似于版本号的机制(称为"stamp")来解决读写冲突。每次获取读锁或写锁时会返回一个stamp,可以用来检查共享数据是否被其他线程修改过。

    • 支持条件等待:StampedLock提供了 Condition 接口的条件等待方法,可以使用条件等待来实现更复杂的线程协调。

  • 前面讲过 ReentrantReadWriteLock 使用方法,与之相比,StampedLock 在某些情况下可以提供更高的性能,但并不是在所有情况下都表现更好。StampedLock 的优势主要表现在支持乐观读取机制条件等待。所以在写操作频繁而读操作较少存在大量的锁竞争的情况下,直接使用悲观读锁,性能跟ReentrantReadWriteLock是相差不大的。

  • 注意:乐观读锁其实没有加锁,就是尝试去读,只要数据没有发生变化,读取的值就有效;否则重新再读一次。乐观读锁就是按这个逻辑执行。

二、使用方法

  • 使用StampedLock的基本步骤如下:

    1. 创建StampedLock对象:通过 StampedLock lock = new StampedLock(); 语句创建StampedLock对象。

    2. 读取操作:使用 lock.tryOptimisticRead() 方法获取一个乐观读锁的 stamp,并读取共享数据。在读取过程中,需要使用lock.validate(stamp) 方法验证读取期间共享数据是否被修改过,如果没有修改再使用悲观读锁,而不是直接使用悲观读锁。

    3. 写入操作:使用 lock.writeLock() 方法获取写锁,并进行写入操作。

    4. 读写锁的转换:可以使用 lock.tryConvertToReadLock(stamp) 或 lock.tryConvertToWriteLock(stamp) 方法将乐观读锁转换为悲观读锁或写锁。这样可以避免释放乐观读锁后再重新获取悲观读锁或写锁。

    import java.util.concurrent.locks.StampedLock;
    
    public class StampedLockExample {
        private Object SharedData;
        private final StampedLock lock = new StampedLock();
    
        public void write(Object obj) {
            //获取写锁
            long stamp = lock.writeLock();
            try {
                // 执行写业务逻辑,如下
                SharedData = obj;
            } finally {
                // 释放写锁
                lock.unlockWrite(stamp);
            }
        }
    
        // 完全使用乐观读锁
        public Object read1() {
            while(true){
                Object result = null;
                
                // 获取乐观读锁
                long stamp = lock.tryOptimisticRead(); 
                // 执行读业务逻辑,如下
                result = SharedData;
                // 验证共享数据是否被修改,如果没有被修改过,则直接返回。否则重新读
                if (lock.validate(stamp)) {
    		      return result;
                }
            }
        }
        
        // 使用乐观读锁 + 非观读锁
        public Object read2() {
            Object result = null;
            
            // 获取乐观读锁
            long stamp = lock.tryOptimisticRead(); 
            // 执行读业务逻辑(这里先读一次),如下
            result = SharedData;
            
            // 验证共享数据是否被修改
            if (lock.validate(stamp)) {
                // 如果共享数据没有被修改过,则直接使用
                return result;
            }
            
            // 获取悲观读锁
            stamp = lock.readLock();
            try {
                // 执行读业务逻辑,重新读
                result = SharedData;
            } finally {
                // 释放写锁
                lock.unlockRead(stamp);
            }
            
            return result;
        }
    }
    

三、测试示例

  • 在下面示例中,创建了一个 StampedLockExample 类,他包括一个写方法,一个乐观读方法和一个乐观结合悲观的读方法。在 main 方法使用1个线程调用写方法,5个线程调用乐观锁读方法,5个线程调用乐观锁加悲观乐的读方法。两个读方法在实际应用中任选一种即可。

    使用StampedLock时需要注意以下几点:

    • 使用乐观读取时,需要在读取操作的开始和结束处进行验证,以确保读取期间共享数据没有被修改。
    • 第一种读取方法是:验证后如果修改,则重新读一次再验证,直到没有被修改则返回
    • 第二种读取方法是:在使用乐观读取之后,如果发现共享数据被修改,尝试转换为悲观读锁或写锁,以避免重新获取锁。
    • 写锁的获取是独占的,会阻塞其他读取和写入操作。因此,在使用写锁时需要注意避免写锁的持有时间过长,避免对性能造成影响。
    package top.yiqifu.study.p004_thread;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.locks.StampedLock;
    
    public class Test081_StampedLock {
    
        public static void main(String[] args) {
            StampedLockExample stampedLockExample = new StampedLockExample();
    
            List<Thread> threads = new ArrayList();
            for(int i = 1; i<= 1; i++){
                Thread t = new Thread(()->{
                    for(int j=0; j< 100000; j++){
                        try {
                            String text = Thread.currentThread().getName()+" 共享数据 "+ j;
                            stampedLockExample.write(text);
                            System.out.println(text);
    
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.setName("写线程"+i);
                threads.add(t);
            }
            for(int i = 1; i<= 5; i++){
                Thread t = new Thread(()->{
                    for(int j=0; j< 100000; j++){
                        try {
                            String result = stampedLockExample.read1();
                            System.out.println(Thread.currentThread().getName()+" 读取 "+result);
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.setName("乐观读线程"+i);
                threads.add(t);
            }
            for(int i = 1; i<= 5; i++){
                Thread t = new Thread(()->{
                    for(int j=0; j< 100000; j++){
                        try {
                            String result = stampedLockExample.read1();
                            System.out.println(Thread.currentThread().getName()+" 读取 "+result);
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.setName("乐+悲读线程"+i);
                threads.add(t);
            }
    
            for(Thread t : threads){
                t.start();
            }
    
            for(Thread t : threads){
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
    
    
        public static class StampedLockExample {
            private String SharedData;
            private final StampedLock lock = new StampedLock();
    
            public void write(String text) {
                long stamp = lock.writeLock();
                try {
                    SharedData = text;
                } finally {
                    lock.unlockWrite(stamp);
                }
            }
    
            // 完全使用乐观读锁
            public String read1() {
                while(true){
                    String result = null;
    
                    long stamp = lock.tryOptimisticRead();
                    result = SharedData;
                    if (lock.validate(stamp)) {
                        return result;
                    }
                }
            }
    
            // 使用乐观读锁 + 非观读锁
            public String read2() {
                String result = null;
    
                long stamp = lock.tryOptimisticRead();
                result = SharedData;
                if (lock.validate(stamp)) {
                    return result;
                }
    
                stamp = lock.readLock();
                try {
                    result = SharedData;
                } finally {
                    lock.unlockRead(stamp);
                }
    
                return result;
            }
        }
    }
    
    

你可能感兴趣的:(Java,java,开发语言,多线程)