Java中的读写锁

最新推荐文章于 2024-05-01 07:08:38 发布
最新推荐文章于 2024-05-01 07:08:38 发布
阅读量524 收藏 12
点赞数 8
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_GIA/article/details/135666039
版权

一、ReentrantReadWriteLock

两个线程同时读取，不会互斥:

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        //Thread.sleep(1000);
        new Thread(dataContainer::read, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}


13:52:32.177 [t2] DEBUG juc.readwrite.DataContainer - 获取读锁
13:52:32.177 [t1] DEBUG juc.readwrite.DataContainer - 获取读锁
13:52:32.180 [t1] DEBUG juc.readwrite.DataContainer - 读取
13:52:32.180 [t2] DEBUG juc.readwrite.DataContainer - 读取
13:52:33.181 [t1] DEBUG juc.readwrite.DataContainer - 释放读锁
13:52:33.181 [t2] DEBUG juc.readwrite.DataContainer - 释放读锁

一个线程读取，一个线程写入，会互斥：

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::read, "t1").start();
        Thread.sleep(1000);
        new Thread(dataContainer::write, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}

13:53:26.922 [t1] DEBUG juc.readwrite.DataContainer - 获取读锁
13:53:26.924 [t1] DEBUG juc.readwrite.DataContainer - 读取
13:53:27.928 [t1] DEBUG juc.readwrite.DataContainer - 释放读锁
13:53:27.929 [t2] DEBUG juc.readwrite.DataContainer - 获取写锁
13:53:27.929 [t2] DEBUG juc.readwrite.DataContainer - 写入
13:53:28.931 [t2] DEBUG juc.readwrite.DataContainer - 释放写锁

两个线程读同时写入，会互斥：

@Slf4j
public class ReadWriteLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainer dataContainer = new DataContainer();
        new Thread(dataContainer::write, "t1").start();
        Thread.sleep(1000);
        new Thread(dataContainer::write, "t2").start();
    }
}

@Slf4j
class DataContainer {
    private Object data;
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    public Object read() {
        readLock.lock();
        log.debug("获取读锁");
        try {
            log.debug("读取");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return data;
        } finally {
            readLock.unlock();
            log.debug("释放读锁");
        }
    }

    public void write() {
        writeLock.lock();
        log.debug("获取写锁");
        try {
            log.debug("写入");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
            writeLock.unlock();
            log.debug("释放写锁");
        }
    }
}

13:55:19.834 [t1] DEBUG juc.readwrite.DataContainer - 获取写锁
13:55:19.837 [t1] DEBUG juc.readwrite.DataContainer - 写入
13:55:20.840 [t1] DEBUG juc.readwrite.DataContainer - 释放写锁
13:55:20.849 [t2] DEBUG juc.readwrite.DataContainer - 获取写锁
13:55:20.849 [t2] DEBUG juc.readwrite.DataContainer - 写入
13:55:21.850 [t2] DEBUG juc.readwrite.DataContainer - 释放写锁
1.读锁不支持条件变量
2.锁升级不支持重入

持有读锁的情况下去获取写锁，会导致写锁永久等待:

r.lock();
try{
  //...
  w.lock();
  try{
    //...
  } finally{
    w.unlock();
 }
} finally{
  r.unlock();
}
3.锁降级支持重入

持有写锁的情况下去获取读锁，支持。

class CachedData {
    Object data;
    // 是否有效，如果失效，需要重新计算 data
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
            //获取写锁前必须释放读锁
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // 判断是否有其它线程已经获取了写锁、更新了缓存，避免重复更新
                if (!cacheValid) {
                    data = ...
                    cacheValid = true;
                }
                // 降级为读锁，释放写锁，这样能够让其它线程读取缓存
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock();
            }
        }
        // 自己用完数据，释放读锁
        try {
            use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

二、缓存更新策略

1.先清缓存，再更新数据库

先清缓存.png

2.先更新数据库，再清缓存

image.png

使用读写锁解决：

public class TestGenericDao {
    public static void main(String[] args) {
        GenericDao dao = new GenericDaoCached();
        System.out.println("============> 查询");
        String sql = "select * from emp where empno = ?";
        int empno = 7369;
        Emp emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);

        System.out.println("============> 更新");
        dao.update("update emp set sal = ? where empno = ?", 800, empno);
        emp = dao.queryOne(Emp.class, sql, empno);
        System.out.println(emp);
    }
}

class GenericDaoCached extends GenericDao {
    private GenericDao dao = new GenericDao();
    private Map<SqlPair, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();

    @Override
    public <T> List<T> queryList(Class<T> beanClass, String sql, Object... args) {
        return dao.queryList(beanClass, sql, args);
    }

    @Override
    public <T> T queryOne(Class<T> beanClass, String sql, Object... args) {
        // 先从缓存中找，找到直接返回
        SqlPair key = new SqlPair(sql, args);;
        rw.readLock().lock();
        try {
            T value = (T) map.get(key);
            if(value != null) {
                return value;
            }
        } finally {
            rw.readLock().unlock();
        }
        rw.writeLock().lock();
        try {
            // 多个线程
            T value = (T) map.get(key);
            if(value == null) {
                // 缓存中没有，查询数据库
                value = dao.queryOne(beanClass, sql, args);
                map.put(key, value);
            }
            return value;
        } finally {
            rw.writeLock().unlock();
        }
    }

    @Override
    public int update(String sql, Object... args) {
        rw.writeLock().lock();
        try {
            // 先更新库
            int update = dao.update(sql, args);
            // 清空缓存
            map.clear();
            return update;
        } finally {
            rw.writeLock().unlock();
        }
    }

    class SqlPair {
        private String sql;
        private Object[] args;

        public SqlPair(String sql, Object[] args) {
            this.sql = sql;
            this.args = args;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            SqlPair sqlPair = (SqlPair) o;
            return Objects.equals(sql, sqlPair.sql) &&
                    Arrays.equals(args, sqlPair.args);
        }

        @Override
        public int hashCode() {
            int result = Objects.hash(sql);
            result = 31 * result + Arrays.hashCode(args);
            return result;
        }
    }
}

三、StampedLock

JDK 8 加入，是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用：
加解读锁：

long stamp = lock.readLock();
lock.unlockRead(stamp);

加解写锁:

long stamp = lock.writeLock();
lock.unlockWrite(stamp);

乐观读
乐观读，StampedLock 支持 tryOptimisticRead() 方法（乐观读），读取完毕后需要做一次 戳校验， 如果校验通过，表示这期间确实没有写操作，数据可以安全使用，如果校验没通过，需要重新获取读锁，保证数据安全。

long stamp = lock.tryOptimisticRead();
// 验戳
if(!lock.validate(stamp)){
// 锁升级
}

读读，使用乐观读：

package juc.readwrite;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.StampedLock;


@Slf4j
public class StampedLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainerStamped dataContainer = new DataContainerStamped(1);
        new Thread(() -> dataContainer.read(1000), "t1").start();
        Thread.sleep(500);
        new Thread(() -> dataContainer.read(0), "t2").start();
    }
}

@Slf4j
class DataContainerStamped {
    private int data;
    private final StampedLock lock = new StampedLock();

    public DataContainerStamped(int data) {
        this.data = data;
    }

    public int read(int readTime) {
        long stamp = lock.tryOptimisticRead();
        log.debug("optimistic read locking...{}", stamp);
        try {
            Thread.sleep(readTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (lock.validate(stamp)) {
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        }
        // 锁升级 - 读锁
        log.debug("updating to read lock... {}", stamp);
        try {
            stamp = lock.readLock();
            log.debug("read lock {}", stamp);
            try {
                Thread.sleep(readTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("read finish...{}, data:{}", stamp, data);
            return data;
        } finally {
            log.debug("read unlock {}", stamp);
            lock.unlockRead(stamp);
        }
    }

    public void write(int newData) {
        long stamp = lock.writeLock();
        log.debug("write lock {}", stamp);
        try {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.data = newData;
        } finally {
            log.debug("write unlock {}", stamp);
            lock.unlockWrite(stamp);
        }
    }
}

16:32:53.802 [t1] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:32:54.299 [t2] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:32:54.300 [t2] DEBUG juc.readwrite.DataContainerStamped - read finish...256, data:1
16:32:54.814 [t1] DEBUG juc.readwrite.DataContainerStamped - read finish...256, data:1

读写，乐观读升级为读锁：

@Slf4j
public class StampedLockTest {
    public static void main(String[] args) throws InterruptedException {
        DataContainerStamped dataContainer = new DataContainerStamped(1);
        new Thread(() -> dataContainer.read(1000), "t1").start();
        Thread.sleep(500);
        new Thread(() -> dataContainer.write(1000), "t2").start();
    }
}

16:35:01.050 [t1] DEBUG juc.readwrite.DataContainerStamped - optimistic read locking...256
16:35:01.548 [t2] DEBUG juc.readwrite.DataContainerStamped - write lock 384
16:35:02.057 [t1] DEBUG juc.readwrite.DataContainerStamped - updating to read lock... 256
16:35:03.549 [t2] DEBUG juc.readwrite.DataContainerStamped - write unlock 384
16:35:03.549 [t1] DEBUG juc.readwrite.DataContainerStamped - read lock 513
16:35:04.551 [t1] DEBUG juc.readwrite.DataContainerStamped - read finish...513, data:1000
16:35:04.551 [t1] DEBUG juc.readwrite.DataContainerStamped - read unlock 513

不支持条件变量，不支持重入

我可能是个假开发
关注
  • 8
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发多线程编程——读写锁的理解与代码示例
小志的博客
04-26 356
目录一、读写锁的理解二、读写锁的代码示例三、多个线程进行读操作的测试案例四、多个线程进行写操作的测试案例五、多个线程进行读写操作的测试案例 一、读写锁的理解 读写锁实际维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁，使得其并发性比独占式锁(排他锁)有了很大的提升。 读锁（共享锁）：同一时刻可以允许多个线程访问共享资源。 写锁（排他锁）：在写线程访问的时候，所有的读线程和其他写线程都会被阻塞。即如果一个线程想要去写共享资源，就不应该再有其他线程可以对该共享资源进行读或者是写操作了。 二、读写锁的代码
Java 读写锁 ReadWriteLock 原理与应用场景详解
萌兔兔MMQ！！
09-30 3809
主要是为了保证数据的可见性，如果当前线程不获取读锁而直接释放写锁，假设此刻另一个线程获取的写锁，并修改了数据，那么当前线程就步伐感知到线程T的数据更新，如果当前线程遵循锁降级的步骤，那么线程T将会被阻塞，直到当前线程使数据并释放读锁之后，线程T才能获取写锁进行数据更新。或者锁状态不为零，而写锁的状态也不为0，但是获取写锁的线程不是当前线程，则当前线程不能获取写锁。公平性：读写锁支持非公平和公平的锁获取方式，非公平锁的吞吐量优于公平锁的吞吐量，默认构造的是非公平锁。
读写锁精讲：Java中使用ReadWriteLock提升性能的终极指南
最新发布
逆流的小鱼
05-01 1407
在并发编程中，ReadWriteLock是一个锁，它允许多个线程同时读共享数据，而写操作则是互斥的。这意味着如果没有线程正在对数据进行写入，那么多个线程可以同时进行读取操作，从而提高程序的性能和吞吐量。
【JAVA】谈谈 ReadWriteLock 和 StampedLock
AliceNo的博客
01-13 1597
在多线程编程中，对共享资源的读写操作是一个常见的挑战。Java并发包中提供了和两种灵活的锁机制，分别在不同场景下提供了高效的并发控制。深入理解它们的原理、用法以及适用场景，对于提高多线程应用的性能和可维护性至关重要。和为我们在多线程环境中进行读写操作提供了强大的支持。适用于读写操作相对均衡的场景，而则在读多写少的情况下可能更为高效。在实际应用中，根据具体的需求和性能优化目标，选择适合的锁机制是关键。通过深入研究和灵活运用这两种锁机制，希望你能够更加高效地处理多线程编程中的共享资源访问。
Java读写锁ReadWriteLock
Charge8的博客
06-26 796
一、读写锁ReadWriteLock ReadWriteLock 是 JDK 中的读写锁接口，提供了 readLock 和 writeLock 两种锁的操作机制，一个是读锁，一个是写锁。 ReadWriteLock同Lock一样也是一个接口，ReentrantLock 是Lock的一种实现，ReentrantReadWriteLock 是 ReadWriteLock 的一种实现。 ReadWriteLock 中只有写锁支持Condition，读锁不支持，读锁调用 newCondition() 方法，会
Java ReadWriteLock读写锁
m0_46580493的博客
04-25 169
Java ReadWriteLock读写锁
Java 锁系列（二）——ReentrantLock 和 ReadWriteLock基础运用
玖涯博客
09-24 452
Lock 接口提供了与 synchronized 相似的功能，和 synchronized 不同的是，Lock 在使用的时候需要显示的获取和释放锁。虽然牺牲了隐式获取释放锁的便捷性，但是对于锁的操作具有更强的可操作性、可控制性以及提供可中断操作和超时获取锁等机制。本文将描述 ReentrantLock 和 ReadWriteLock 锁的基础使用。 一、ReentrantLock 运用 package com.nineya.test; import java.util.concurrent.Executo
Java编程读写锁详解
08-27
Java编程读写锁是Java并发编程中的一种重要机制，用于解决多线程访问同一个资源时的安全问题。在Java中，读写锁是通过ReadWriteLock接口实现的，该接口提供了readLock和writeLock两种锁的操作机制，一个资源可以被多...
Java 读写锁实现原理浅析
08-27
Java 读写锁实现原理浅析是 Java 并发编程中一个非常重要的主题。在多线程编程中，读写锁是解决读写并发问题的常用机制。本文主要介绍了 Java 读写锁实现原理浅析，包括读写锁的定义、读写锁的实现原理、...
举例说明Java多线程编程中读写锁的使用
09-02
Java多线程编程中，读写锁是一种优化并发访问共享资源的有效工具，它允许多个线程同时读取，但只允许一个线程写入。Java的`java.util.concurrent.locks.ReentrantReadWriteLock`类提供了可重入的读写锁功能。下面...
java 读写锁代码
08-22
下面我们将详细探讨Java读写锁的概念、实现原理以及如何在实际代码中应用。 1. **读写锁概念**： - 读写锁分为读锁（共享锁）和写锁（独占锁）。读锁允许多个线程同时读取数据，而写锁只允许一个线程进行写操作。 ...
Java多线程编程之读写锁ReadWriteLock用法实例
09-03
Java的多线程编程中，读写锁（ReadWriteLock）是一种高效的并发控制机制，它将锁的权限进行了区分，允许多个线程同时读取资源，但仅允许一个线程进行写入操作。这种设计模式提高了数据共享的效率，因为读操作通常...
Java中的读/写锁
07-13 905
原文链接 作者：Jakob Jenkov 译者：微凉 校对：丁一 相比Java中的锁(Locks in Java)里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读
Java读写锁ReentrantReadWriteLock原理详解
潘建南的博客
12-18 3207
ReentrantLock属于排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁ReentrantReadWriterLock在同一时刻可以允许多个线程访问，但是在写线程访问时，所有的读和其他写线程都被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。下面我们来看看读写锁ReentrantReadWriter特性公平性选择：支持非公平（默认）和公平的锁获取模式，非公平的吞吐量优于公平；重入性。
java多线程读写锁_Java多线程编程中线程锁与读写锁的使用示例
weixin_42135462的博客
02-12 114
线程锁LockLock 相当于 当前对象的 Synchronizedimport java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** Lock lock = new ReentrantLock();* lock.lock(); lock.unLock();* 类似于 synchr...
java的读写锁_不是我吹！Java的读写锁，看这篇就够了！
weixin_36302268的博客
02-12 661
读写锁的基本使用在【ReentrantLock锁详解】一文中讲到了java中锁的划分，本篇主要讲述共享锁和排他锁：ReentrantReadWriteLock在ReentrantReadWriteLock中包含读锁和写锁，其中读锁是可以多线程共享的，即共享锁，而写锁是排他锁，在更改时候不允许其他线程操作。读写锁其实是一把锁，所以会有同一时刻不允许读写锁共存的规定。之所以要细分读锁和写锁也是为了提高...
java读写锁实现
MisrZong的博客
01-30 235
读写锁
【java】java 锁 ReentrantReadWriteLock 读写锁 源码解读
九师兄
03-12 530
文章目录1.概述2.问题3.数据结构4.源码分析4.1 类的继承关系4.2 类的内部类4.3 内部类 - Sync类4.3.1 类的内部类4.3.2 类的属性4.3.3 类的构造函数4.3.4 内部类 - Sync核心函数分析4.3.4.1 sharedCount函数4.3.4.2 exclusiveCount函数4.3.4.3 tryRelease函数4.3.4.4 tryAcquire函数4.3.4.5 tryReleaseShared函数4.3.4.6 tryAcquireShared函数4.3.4.
java锁：读写锁
qq_41477034的博客
12-31 296
独占锁/共享锁 独占锁：同一时间内只允许一个线程持有该锁，保证数据一致性，Synchronized/ReentrantLock都是独占锁 共享锁：同一时间内允许多个线程持有该锁，多个线程可以操作 读写锁： ReentrantReadWriteLock 读写锁：写操作是独占锁，读操作是共享锁，写独占保证数据一致性，读共享保证并发性 就好比一个成绩单需要签名，但是又可以供多个人一起读，此时同一时...
Java中读写锁怎么用，并附上代码
06-07
在Java中，读写锁是通过`ReentrantReadWriteLock`类实现的。这个类提供了两个锁，一个读锁和一个写锁，可以通过它们来实现对共享数据的读写操作。 下面是一个简单的示例代码，演示了如何使用读写锁来实现对共享数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值