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

QIFU

已于 2023-12-10 17:15:15 修改

阅读量1.1k

点赞数 13

分类专栏： # Java 多线程文章标签： java 开发语言多线程

于 2023-12-05 16:52:42 首次发布

本文链接：https://blog.csdn.net/qifu123/article/details/134811668

版权

Java 多线程专栏收录该内容

20 篇文章 0 订阅

订阅专栏

文章目录

一、概述

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的基本步骤如下：

创建StampedLock对象：通过 StampedLock lock = new StampedLock(); 语句创建StampedLock对象。
读取操作：使用 lock.tryOptimisticRead() 方法获取一个乐观读锁的 stamp，并读取共享数据。在读取过程中，需要使用lock.validate(stamp) 方法验证读取期间共享数据是否被修改过，如果没有修改再使用悲观读锁，而不是直接使用悲观读锁。
写入操作：使用 lock.writeLock() 方法获取写锁，并进行写入操作。
读写锁的转换：可以使用 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;
        }
    }
}

QIFU

关注

13
点赞
踩
17

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 多线程之 StampedLock（读写锁/乐观读锁/共享锁/排他锁）

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

扫一扫