13、ReentrantLock、ReentrantReadWriteLock、StampedLock

于 2022-08-30 14:55:34 发布
阅读量347 收藏 1
点赞数
分类专栏： JUC并发 文章标签： java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PingFanXianSheng/article/details/126603496
版权

目录

无锁—独占锁—读写锁—邮戳锁

1、面试题

2、ReentrantReadWriteLock 可重入读写锁

2.1 可重入读写锁定义

2.2 代码演示

2.2.1 ReentrantLock锁演示

2.2.2 ReentrantReadWriteLock锁演示

2.3 ReentrantReadWriteLock写锁饥饿问题

2.4 ReentrantReadWriteLock锁降级

2.4.1 支持锁降级

2.4.2 不支持锁升级

2.5 锁降级Oracle公司案例

3、StampedLock 邮戳锁 

3.1 是什么

3.2 特点

3.3 常用API 

3.3.1 测试独占锁和共享锁

3.3.2 乐观读

3.3.3 tryConvertToWriteLock 尝试锁转换

3.4 官方案例解读

无锁—独占锁—读写锁—邮戳锁

1、面试题

1.用户读写锁吗，锁饥饿问题是什么？

2.有没有比读写锁更快的锁？(StampedLock锁知道吗？)

3.ReentrantReadWriteLock有锁降级机制，知道吗？

2、ReentrantReadWriteLock 可重入读写锁

其实还是实现的AQS

2.1 可重入读写锁定义

一个资源可以被多个读线程访问，或者被一个写线程访问。但是不能同时存在读写线程

         它只允许读读共存，而读写和写写依然是互斥的，大多实际场景是"读/读"线程间并不存在互斥关系，只有"读/写"线程或“写/写”线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。

        简单的可以理解为读的时候不让写。（这也是导致锁饥饿问题的原因）

        只有再读多写少的情景下，读写锁才具有较高的性能体现。

2.2 代码演示

2.2.1 ReentrantLock锁演示

package com.guigu.juc.aqs;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: gzh
 * @Date: 2022/8/29 14:26
 */
public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {
        MyResource myResource = new MyResource();
        // 先写
        for(int i = 0; i < 10;i++){
            int finalI = i;
            new Thread(() -> {
                myResource.write(String.valueOf(finalI),String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
        // 再读
        for(int i = 0; i < 10;i++){
            int finalI = i;
            new Thread(() -> {
                myResource.read(String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
    }
}

class MyResource{
    Map<String,String> map = new HashMap<>();

    /** ReentrantLock */
    Lock lock = new ReentrantLock();
    /** 读写锁- 读读共享，读写互斥 */
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void write(String key,String val){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写入");
            map.put(key,val);
            TimeUnit.MILLISECONDS.sleep(500);
            System.out.println(Thread.currentThread().getName() + "完成写入");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public String read(String key){
        String result = null;
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在读取");
            result = map.get(key);
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println(Thread.currentThread().getName() + "完成读取 " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return result;
    }
}

2.2.2 ReentrantReadWriteLock锁演示

 /**
 * 修改锁的使用
 */
 public void write(String key,String val){
//        lock.lock();
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写入");
            map.put(key,val);
            TimeUnit.MILLISECONDS.sleep(500);
            System.out.println(Thread.currentThread().getName() + "完成写入");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
//            lock.unlock();
            readWriteLock.writeLock().unlock();
        }
    }

    public String read(String key){
        String result = null;
//        lock.lock();
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在读取");
            result = map.get(key);
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println(Thread.currentThread().getName() + "完成读取 " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
//            lock.unlock();
            readWriteLock.readLock().unlock();
        }
        return result;
    }

2.3 ReentrantReadWriteLock写锁饥饿问题

package com.guigu.juc.aqs;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: gzh
 * @Date: 2022/8/29 14:26
 */
public class ReentrantReadWriteLockDemo {

    public static void main(String[] args) {
        MyResource myResource = new MyResource();
        // 99个读
        for(int i = 0; i < 99;i++){
            int finalI = i;
            new Thread(() -> {
                myResource.read(String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
        
        // 一个写
        new Thread(() -> {
           myResource.write(String.valueOf(1),String.valueOf(1));
        },"写线程").start();
    }
}

class MyResource{
    Map<String,String> map = new HashMap<>();

    /** ReentrantLock */
    Lock lock = new ReentrantLock();
    /** 读写锁- 读读共享，读写互斥 */
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void write(String key,String val){
//        lock.lock();
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写入");
            map.put(key,val);
            TimeUnit.MILLISECONDS.sleep(500);
            System.out.println(Thread.currentThread().getName() + "完成写入");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
//            lock.unlock();
            readWriteLock.writeLock().unlock();
        }
    }

    public String read(String key){
        String result = null;
//        lock.lock();
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在读取");
            result = map.get(key);
//            TimeUnit.MILLISECONDS.sleep(200);
            // 将读的时间调长
            TimeUnit.MILLISECONDS.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "完成读取 " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
//            lock.unlock();
            readWriteLock.readLock().unlock();
        }
        return result;
    }
}

2.4 ReentrantReadWriteLock锁降级

        将写入锁降级为读锁(类似Linux文件读写权限的理解，写的权限要远高于读权限一样)，锁的严苛程度变强叫做升级，反之叫做降级。

写锁的降级，降级成为读锁：

        1、如果同一个线程持有了写锁，再没有释放写锁的情况下，它还可以继续获得读锁。

        2、规则惯例，先获取写锁，然后获取读锁，再释放写锁的次序。

        3、如果释放了写锁，那么就完全转换为读锁。

 

2.4.1 支持锁降级

public static void main(String[] args) {
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    Lock readLock = readWriteLock.readLock();
    Lock writeLock = readWriteLock.writeLock();

    writeLock.lock();
    try {
        System.out.println("获取写锁");
        readLock.lock();
        System.out.println("获取读锁");
    }finally {
        readLock.unlock();
        writeLock.unlock();
    }
}

2.4.2 不支持锁升级

public static void main(String[] args) {
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    Lock readLock = readWriteLock.readLock();
    Lock writeLock = readWriteLock.writeLock();

    readLock.lock();
    try {
        System.out.println("获取读锁");
        writeLock.lock();
        System.out.println("获取写锁");
    }finally {
        readLock.unlock();
        writeLock.unlock();
    }
}

不支持锁升级的原因：

2.5 锁降级Oracle公司案例

 

3、StampedLock 邮戳锁 

3.1 是什么

        StampedLock 是JDK1.8中新增的读写锁，也是多1.5中的读写锁ReentrantReadWriteLock的优化。主要解决写锁饥饿问题。

3.2 特点

        所有获取锁的方法，都返回一个邮戳(stamp)，stamp为0表示获取失败，其余都表示成功。

        所有释放锁的方法，都需要一个邮戳(stamp)，这个Stamp必须和成功获取锁的stamp一直。

        StampedLock是不可重入的，如果一个线程已经持有了写锁，再获取写锁的话会造成死锁。而且它的底层不是AQS。

三种模式：

        1、独占写模式：writeLock方法获取共享状态时阻塞，如果成功获取锁，返回一个stamp，它可以作为参数被用在unlockWrite方法中以释放写锁。tryWriteLock的超时与非超时版本都被提供使用。当写锁被获取，那么没有读锁能够被获取，并且所有的乐观读锁验证都会失败。

        2、悲观读模式：readLock方法可能会在获取共享状态时阻塞，如果成功获取锁，返回一个stamp，它可以作为参数被用在unlockRead方法中以释放读锁。tryReadLock的超时与非超时版本都被提供使用。

        3、乐观读模式：tryOptimisticRead方法只有当写锁没有被获取时会返回一个非0的stamp。在获取这个stamp后直到调用validate方法这段时间，如果写锁没有被获取，那么validate方法将会返回true。（这个模式可以被认为是读锁的一个弱化版本，因为它的状态可能随时被写锁破坏。这个乐观模式的主要是为一些很短的只读代码块的使用设计，它可以降低竞争并且提高吞吐量。但是，它的使用本质上是很脆弱的。乐观读的代码区域应当只读取共享数据并将它们储存在局部变量中以待后来使用，当然在使用前要先验证这些数据是否过期，这可以使用前面提到的validate方法。在乐观读模式下的数据读取可能是非常不一致的过程，因此只有当你对数据的表示很熟悉并且重复调用validate方法来检查数据的一致性时使用此模式。例如，当先读取一个对象或者数组引用，然后访问它的字段、元素或者方法之一时上面的步骤都是需要的。）

        这个类还提供了在三种模式之间转换的辅助方法。例如，tryConvertToWriteLock方法尝试"提升"一个模式，如果已经获取了读锁并且此时没有其他线程获取读锁，那么这个方法返回一个合法的写stamp。这些方法被设计来帮助减少以“重试为主”设计时发生的代码代码膨胀。

3.3 常用API 

方法

说明

long writeLock()

获取独占锁，如果该锁被另一个线程保持，则阻塞线程，直到拿到锁并返回邮戳。

void unlockWrite(long stamp)

如果锁状态与给定的邮戳匹配，则释放独占锁。

long readLock()

获取共享锁，如果该锁被另一个线程保持，则阻塞线程，直到拿到锁并返回邮戳。

void unlockRead(long stamp)

如果锁状态与给定的邮戳匹配，则释放共享锁。

void unlock(long stamp)

如果锁状态与给定的邮戳匹配，则释放锁的相应模式。

long tryOptimisticRead()

如果当前未持有独占锁则返回当前锁版本作为邮戳，用于在以后验证状态，如果已持有独占锁(独占写)则返回0，用于乐观锁。

boolean validate(long stamp)

如果自给定邮戳获取后未获取过独占锁（独占锁状态码未改变），则返回 true。 如果状态为 0，则始终返回 false。

long tryConvertToWriteLock(long stamp)

验证当前锁版本和锁持有状态和给定的邮戳是否匹配，如果不匹配、邮戳的锁状态有误或当前持有多个共享锁则返回0。匹配时则分三种情况，当前未持有锁则获取独占锁，当前持有独占锁则不进行操作，当前仅持有一个共享锁则释放共享锁获取独占锁，最终返回独占锁的邮戳。

API说明测试

公用类

// 测试公用类
public class StampedLockDemo {
    Integer number = -1;
    StampedLock stampedLock = new StampedLock();

    /**
     * 共享读
     * @return
     */
    @SneakyThrows
    public Integer read(){
        Integer num;
        long stamp = stampedLock.readLock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在读");
            TimeUnit.SECONDS.sleep(2);
            num = number;
            System.out.println(Thread.currentThread().getName() + "完成读  " + num);
        }finally {
            stampedLock.unlockRead(stamp);
        }
        return num;
    }

    /**
     * 独占写
     * @param num
     */
    @SneakyThrows
    public void write(Integer num){
        long stamp = stampedLock.writeLock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写");
            number = num;
            TimeUnit.SECONDS.sleep(3);
            System.out.println(Thread.currentThread().getName() + "完成写");
        }finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    /**
     * 乐观读
     * @return
     */
    @SneakyThrows
    public Integer optimisticRead(){
        // 尝试获取乐观读锁
        long stamp = stampedLock.tryOptimisticRead();
        Integer num = number;
        System.out.println(Thread.currentThread().getName() + "正在乐观读 number:" + num);
        TimeUnit.SECONDS.sleep(4);
        // 检查在获取到读锁stamp后，锁有没被其他写线程抢占
        if(!stampedLock.validate(stamp)){
            // 如果被抢占则获取一个共享读锁（悲观获取）
            stamp = stampedLock.readLock();
            System.out.println(Thread.currentThread().getName() + "升级悲观读");
            try {
                num = number;
                System.out.println(Thread.currentThread().getName() + "正在共享读(悲观读) number:" + num);
            }finally {
                stampedLock.unlockRead(stamp);
            }
        }
        System.out.println(Thread.currentThread().getName() + "optimisticRead number:" + num);
        return num;
    }
}

3.3.1 测试独占锁和共享锁

效果与ReentrantReadWriteLock一致，写锁独占，读锁共享

public static void main(String[] args) {
    StampedLockDemo demo = new StampedLockDemo();
    // 十个写
    for(int i = 0; i < 10; i++){
        int finalI = i;
        new Thread(() -> {
            demo.write(finalI);
        },"独占写线程" + i).start();
    }
    // 十个读
    for(int i = 0; i < 10; i++){
        new Thread(() -> {
            demo.read();
        },"共享读线程" + i).start();
    }
}

3.3.2 乐观读

public static void main(String[] args) {
    StampedLockDemo demo = new StampedLockDemo();
    // 十个写
    for(int i = 0; i < 10; i++){
        int finalI = i;
        new Thread(() -> {
            demo.write(finalI);
        },"独占写线程" + i).start();
    }
    // 三个读
    for(int i = 0; i < 3; i++){
        new Thread(() -> {
            demo.optimisticRead();
        },"乐观读线程" + i).start();
    }
}

3.3.3 tryConvertToWriteLock 尝试锁转换

@SneakyThrows
public static void main(String[] args) {
    StampedLockDemo demo = new StampedLockDemo();
    long stamped = demo.stampedLock.tryOptimisticRead();
    // 让其他线程持有独占锁
    new Thread(() -> {
        demo.write(10);
    },"独占写线程").start();

    TimeUnit.MILLISECONDS.sleep(1000);
    long convert = demo.stampedLock.tryConvertToWriteLock(stamped);
    try {
        System.out.println(Thread.currentThread().getName() + "尝试转换WriteLock(0:失败,其他成功):" + convert);
    }finally {
        if(convert != 0){
            demo.stampedLock.unlockWrite(convert);
        }
    }
}

3.4 官方案例解读

package com.guigu.juc.aqs;

import java.util.concurrent.locks.StampedLock;

/**
 * @Author: gzh
 * @Date: 2022/8/30 11:06
 */
public class Point {
    /** 成员变量 */
    private double x, y;

    /** 锁实例 */
    private final StampedLock sl = new StampedLock();

    /** 排它锁-写锁（writeLock） */
    void move(double deltaX, double deltaY) {
        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    /**
     * 一个只读方法
     * 其中存在乐观读锁到悲观读锁的转换
     * @return
     */
    double distanceFromOrigin() {
        // 尝试获取乐观读锁
        long stamp = sl.tryOptimisticRead();
        // 将全部变量拷贝到方法体栈内
        double currentX = x, currentY = y;
        // 检查在获取到读锁stamp后，锁有没被其他写线程抢占
        if (!sl.validate(stamp)) {
            // 如果被抢占则获取一个共享读锁（悲观获取）
            stamp = sl.readLock();
            try {
                // 将全部变量拷贝到方法体栈内
                currentX = x;
                currentY = y;
            } finally {
                // 释放共享读锁
                sl.unlockRead(stamp);
            }
        }
        // 返回计算结果
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    /**
     * 获取读锁，并尝试转换为写锁
     * @param newX
     * @param newY
     */
    void moveIfAtOrigin(double newX, double newY) {
        long stamp = sl.tryOptimisticRead();
        try {
            // 如果当前点在原点则移动
            while (x == 0.0 && y == 0.0) {
                // 尝试将获取的读锁升级为写锁：
                // 返回0的情况 1、验证锁版本和持有锁版本不一致 2、多个线程持有共享读锁
                long ws = sl.tryConvertToWriteLock(stamp);
                // 升级成功，则更新stamp，并设置坐标值，然后退出循环
                if (ws != 0L) {
                    stamp = ws;
                    x = newX;
                    y = newY;
                    break;
                } else {
                    // 读锁升级写锁失败则释放读锁，显示获取独占写锁，然后循环重试
                    sl.unlockRead(stamp);
                    stamp = sl.writeLock();
                }
            }
        } finally {
            sl.unlock(stamp);
        }
    }
}

郭吱吱
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC知识点总结（三）ReentrantLock与ReentrantReadWriteLock源码解析
01-21
8. Lock接口 （ReentrantLock 可重入锁） 特性 ReentantLock 继承接口 Lock 并实现了接口中定义的方法， 它是一种可重入锁， 除了能完成 synchronized 所能完成的所有工作外，还提供了诸如可响应中断锁、可轮询锁请求、定时锁等 避免多线程死锁的方法。 尝试非阻塞地获取锁：tryLock()，调用方法后立刻返回； 能被中断地获取锁：lockInterruptibly()：在锁的获取中可以中断当前线程 超时获取锁：tryLock(time,unit)，超时返回 Condition 类和 Object 类锁方法区别区别 Condition 类的 awiat
ReentrantLock、ReentrantReadWriteLock、StampedLock
散步的博客
04-05 354
ReentrantReadWriteLock 读写锁定义为： 一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。 ReentrantReadWriteLock 并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的， 大多实际场景是 读读线程间并不存在互斥关系，只有读、写线程 或者是写写线程间的操作需要互斥的。 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁(切菜还是拍蒜选一个)。 也即一个
高并发之——浅谈AQS中的ReentrantLock、ReentrantReadWriteLock、StampedLock与Condition
冰河的专栏
03-19 1411
ReentrantLock 概述 Java中主要分为两类锁，一类是synchronized修饰的锁，另外一类就是J.U.C中提供的锁。J.U.C中提供的核心锁就是ReentrantLock。 ReentrantLock（可重入锁）与synchronized区别： （1）可重入性 二者都是同一个线程进入1次，锁的计数器就自增1，需要等到锁的计数器下降为0时，才能释放锁。 （2）锁的实现 synchr...
并发编程实战13-同步中的四种锁synchronized、ReentrantLock、ReentrantReadWriteLock、StampedLock
SoundSlow的博客
04-17 645
synchronized同步锁 synchronized属于悲观锁，直接对区域或者对象加锁，性能稳定，可以使用大部分场景。 ReentrantLock可重入锁（Lock接口） 相对于synchronized更加灵活，可以控制加锁和放锁的位置 可以使用Condition来操作线程，进行线程之间的通信 核心类AbstractQueuedSynchronizer，通过构造一个基于阻塞的CLH队列容...
synchronized，ReentrantLock、ReentrantReadWriteLock和StampedLock
进化的深山猿
01-23 873
java四种上锁方式原理及适用场景区分 synchronized（monitor）、ReentantLock（AQS）、AtomicLong（CAS）、LongAdder（XADD） 针对代码块需要同步的锁 synchronized---锁竞争不激烈的场景 竞争不激烈的时候，各种锁优化机制会发挥作用（如轻量级锁、偏向锁、自旋锁、锁消除等），如果竞争激烈，会使用重量级锁，性能下降。 Reentan...
contention-profiling:ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
06-10
争用分析 ReentrantLock 和 ReentrantReadWriteLock 上的配置文件争用
ReentrantLock实现原理详解
08-31
本文将对ReentrantLock实现原理进行详细的介绍，具有很好的参考价值，下面跟着小编一起来看下吧
ReentrantLock.java
02-24
ReentrantLock.java
java ReentrantLock详解
08-26
主要介绍了java ReentrantLock，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
4.9 ReentrantLock、ReentrantReadWriteLock、StampedLock实现原理以及特点；
服务端开发进阶之路
04-12 211
ReentrantLock java除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。 而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。 ReentrantLock常常对比着synchronized来分析，我们先对比着来看然后再一点一点分析。 （1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。 ReentrantLock也是独占锁，加锁和解锁的过程..
Java多线程synchronized、ReentrantLock、ReentrantReadWriteLock 和StampedLock 的对比
YEN_CSDN的博客
06-17 1798
synchronized是在JVM层面上实现的，可以通过一些监控工具控制synchronized的锁定，当代码出现异常时，JVM会自动释放锁定。当只有少量竞争者的时候，synchronized是一个很好的通用的锁实现。synchronized的锁是针对一个对象的。 ReentrantLock、ReentrantReadWriteLock 和StampedLock都是代码层面的锁定，要保证锁一定会被释
并发编程9-公平锁&ReentrantReadWriteLock&StampedLock
bobshute的专栏
02-16 332
1.公平锁/非公平锁 1.1 公平锁概述 公平是针对锁的获取而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序。 ReentrantLock、ReadWriteLock默认都是非公平模式,非公平锁的效率高于公平锁(不浪费的线程切换). 1.2 自写公平锁 FairLock,QueueObject import java.util.ArrayList; import java....
无锁-＞ReentrantLock-＞ReentrantReadWriteLock-＞StampedLock讲解
枫陵的博客
05-08 675
一. 概述 锁的演变过程 无锁->独占锁->读写锁->邮戳锁 1. 无锁：多线程抢占，数据混乱，无序 2. ReentrantLock、synchronized：有序，数据一致性，每次只能来一个线程，不管什么操作 缺点：读操作效率低 3. ReentrantReadWriteLock：读写互斥，读读可以共享，提升大面积的共享性能，同时多人读。 缺点： 1. 锁饥饿问题，写线程获得不到锁 2. 读的过程中，如果没有释放,写线程不可以获得...
ReentrantLock 和 ReentrantReadWriteLock 详解
GeGe&YoYo的博客
07-29 344
ReentrantLock AQS ReentrantReadWriteLock 详解
【并发编程】浅析重入锁ReentrantLock与读写锁ReadWriteLock
Stay Hungry, Stay Foolish!
11-04 419
文章目录1 Lock接口1.1 Lock与synchronized1.2 Lock接口方法2 ReentrantLock2.1 可重入2.2 公平/非公平2.3 小结2.4 中断与超时等待3 ReadWriteLock3.1 读锁3.1.1 读锁加锁3.1.2 读锁释放3.2 写锁3.2.1 写锁加锁3.2.2 写锁释放3.3 小结参考 1 Lock接口 1.1 Lock与synchronized 在Lock接口出现之前，Java程序是靠synchronized关键字用来实现锁功能，使用时隐式地获取和释放锁
Java多线程（十）之ReentrantReadWriteLock深入分析
爱.NET
12-15 231
一、ReentrantReadWriteLock与ReentrantLock 说到ReentrantReadWriteLock，首先要做的是与ReentrantLock划清界限。它和后者都是单独的实现，彼此之间没有继承或实现的关系。 ReentrantLock 实现了标准的互斥操作，也就是一次只能有一个线程持有锁，也即所谓独占锁的概念。前面的章节中一直在强调这个特点。显然这个特...
21 ReentrantLock(重入锁) & ReentrantReadWriteLock(读写锁)
Vision
07-04 697
 锁(重入锁，读写锁)它们具有比synchronized更为强大的功能，并且有嗅探锁定、多路分支等功能。重入锁，在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，不然会造成锁永远无法释放，其他线程永远进不去的结果。  package edu.sdut.lock; import java.util.concurrent.CopyOnWriteArrayList; imp...
ReentrantLock， ReentrantReadWriteLock
最新发布
07-27
ReentrantLock和ReentrantReadWriteLock是Java中用于线程同步的锁机制。 ReentrantLock是一个可重入的互斥锁，也就是说同一个线程可以多次获得该锁。它提供了与synchronized关键字类似的功能，但是具有更灵活的控制能力。ReentrantLock提供了公平锁和非公平锁两种模式，默认情况下使用非公平锁。公平锁会按照请求锁的顺序来获得锁，而非公平锁则不保证线程获取锁的顺序。ReentrantLock还支持条件变量，通过Condition接口可以实现更加精细的线程等待/唤醒机制。 ReentrantReadWriteLock是一个可重入的读写锁，它允许多个线程同时读共享资源，但只允许一个线程写共享资源。这种锁适用于读操作远远多于写操作的场景，可以提高并发性能。和ReentrantLock类似，ReentrantReadWriteLock也提供了公平模式和非公平模式，默认使用非公平模式。 在使用ReentrantLock和ReentrantReadWriteLock时，需要注意遵循以下原则： - 获取锁后，要及时释放锁，以免造成死锁。 - 避免出现重复获取同一个锁的情况，以免引起死锁。 - 在使用ReentrantReadWriteLock时，要根据实际情况选择读锁和写锁，避免出现线程饥饿的情况。 以上是对ReentrantLock和ReentrantReadWriteLock的简单介绍，如果还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

郭吱吱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值