JAVA并发编程：读写锁ReentrantReadWriteLock的基本使用及JDK源码中金典案例分析

最新推荐文章于 2022-09-08 23:28:29 发布
最新推荐文章于 2022-09-08 23:28:29 发布
阅读量235 收藏 1
点赞数 1
分类专栏： Java 并发编程 文章标签： java 并发编程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lspj201007186/article/details/108629150
版权

1、读写锁简介

  之前提到锁（如 Mutex 和ReentrantLock）基本都是排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。
  读写锁维护了一对锁，一个读锁和一个写锁，读写锁在 ReentrantLock 上进行了拓展，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。
  除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁能够简化读写交互场景的编程方式。假设在程序中定义一个共享的用作缓存数据结构，它大部分时间提供读服务（例如查询和搜索），而写操作占有的时间很少，但是写操作完成之后的更新需要对后续的读服务可见。
  一般情况下，读写锁的性能都会比排它锁要好，因为大多数场景读是多于写的。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。

2、读写锁的基本使用

  读写锁的基本使用，使用也是非常简单，跟 ReentrantLock 差不多，唯一不同的是读锁需要调用 readLock() 方法获取，写锁需要调用 writeLock() 方法获取，一般情况下掌握以下几种即可，读读并发、读写互斥、写写互斥、不支持锁升级、支持锁降级、支持锁重入、读锁不支持条件、写锁支持条件。下面给大家一一来分析以上这几种情况的基本使用，示例代码如下。

  • 读读并发
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock1 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 读读并发
     * 执行结果：可以同时输出线程 t1 和 t2 信息
     */
    public void m1() {
        // 读锁
        new Thread(() -> {
            r.lock();

            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
            } finally {
                r.unlock();
            }
        }, "t1").start();


        // 读锁
        new Thread(() -> {
            r.lock();
            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
            } finally {
                r.unlock();
            }
        }, "t2").start();
    }

    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args)  {
        ReadWriteLock1 rwl = new ReadWriteLock1();
        //1、读读并发
        rwl.m1();
    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 和 t2 在同一时刻都拿到了读锁，后面再打印相应信息。因此，能证明读锁是可以并发执行的。

  • 读写互斥
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock2 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");


    /**
     * 读写互斥
     * 执行结果：线程 t1 和 t2，谁先拿到锁就先执行完释放锁，第二个线程才可以拿到锁再执行
     */
    public void m2() {
        // 读锁
        new Thread(() -> {
            r.lock();
            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                r.unlock();
            }
        }, "t1").start();


        // 写锁
        new Thread(() -> {
            w.lock();
            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
            } finally {
                w.unlock();
            }
        }, "t2").start();
    }


    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args)  {
        ReadWriteLock2 rwl = new ReadWriteLock2();
        //2、读写互斥
        rwl.m2();
    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 和 t2，谁先拿到锁就先执行完释放锁，第二个线程才可以拿到锁再执行。因此，能证明读写锁是互斥执行的。

  • 写写互斥
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock3 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");


    /**
     * 写写互斥
     * 执行结果：线程 t1 和 t2，谁先拿到锁就先执行完释放锁，第二个线程才可以拿到锁再执行
     */
    public void m3() {
        // 写锁
        new Thread(() -> {
            w.lock();
            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                w.unlock();
            }
        }, "t1").start();


        // 写锁
        new Thread(() -> {
            w.lock();
            System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
            try {
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
            } finally {
                w.unlock();
            }
        }, "t2").start();
    }


    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args)  {
        ReadWriteLock3 rwl = new ReadWriteLock3();
        //3、写写互斥
        rwl.m3();
    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 和 t2，谁先拿到锁就先执行完释放锁，第二个线程才可以拿到锁再执行。因此，能证明写写锁是互斥执行的。

  • 不支持锁升级
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock4 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 先获取读锁，再获取写锁，不支持锁升级
     */
    public void m4() {
        // 读锁
        new Thread(() -> {
            r.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
                w.lock();
                try {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
                    for (int i = 0; i < 5; i++) {
                        System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                    }

                } finally {
                    w.unlock();
                }
            } finally {
                r.unlock();
            }
        }, "t1").start();
    }

    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args)  {
        ReadWriteLock4 rwl = new ReadWriteLock4();
        //4、不支持锁升级
        rwl.m4();
    }
}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 先获取读锁，再想去获取写锁，一直拿不到，处于阻塞状态。因此，能证明读写锁不支持锁升级。

  • 支持锁降级
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock5 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 支持重入，支持锁降级
     */
    public void m5() {
        // 读锁
        new Thread(() -> {
            w.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
                for (int i = 0; i < 5; i++) {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                r.lock();
                try {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
                    for (int i = 0; i < 5; i++) {
                        System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + ",i=" + i);
                    }

                } finally {
                    r.unlock();
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " release read lock ...");
                }
            } finally {
                w.unlock();
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " release write lock ...");
            }
        }, "t1").start();
    }

    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args) {
        ReadWriteLock5 rwl = new ReadWriteLock5();
        //5、支持锁降级
        rwl.m5();
    }
}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 获取写锁后执行完相关业务逻辑，未释放写锁，可以直接获取读锁执行相关业务。因此，能证明读写锁支持锁降级。

  • 读写锁，支持锁重入
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock6 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 读写锁，支持重入
     */
    public void m6() {
        // 读锁重入
        new Thread(() -> {
            r.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
                r.lock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " once again get read lock ...");
                } finally {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    r.unlock();
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " release read lock ...");
                }
            } finally {
                r.unlock();
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + "  release read lock ...");
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 写锁重入
        new Thread(() -> {
            w.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
                w.lock();
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " once again get write lock ...");
                } finally {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    w.unlock();
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " release write lock ...");
                }
            } finally {
                w.unlock();
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + "  release write lock ...");
            }
        }, "t2").start();
    }



    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args) throws InterruptedException {
        ReadWriteLock6 rwl = new ReadWriteLock6();
        //6、读写锁，支持重入
        rwl.m6();
    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 先获取一把读锁，执行完相关业务后，在未释放锁的情况下，可以直接再次获取到同一把读锁，线程 t2 也是如此。因此，能证明读写锁是支持重入的。

  • 读写锁，读锁不支持条件
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock7 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 读写锁，读锁不支持条件
     */
    public void m7() {
        // 读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
        Condition condition = r.newCondition();
        // 读锁，上面调用就抛异常了，都不会执行到这
        new Thread(() -> {
            r.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get read lock ...");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                r.unlock();
            }
        }, "t1").start();
    }


    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args) throws InterruptedException {
        ReadWriteLock7 rwl = new ReadWriteLock7();
        //7、读写锁，读锁不支持条件
        rwl.m7();
    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，代码执行到 Condition condition = r.newCondition(); 这一行直接抛异常，读锁的条件直接调用 ReentrantReadWriteLock 的 newCondition 会直接exception。因此，能证明读锁不支持条件。

  • 读写锁，写锁支持条件
package com.enjoy.lspj.rwl;

import java.text.SimpleDateFormat;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁的使用
 * 1、读读并发
 * 2、读写互斥
 * 3、写写互斥
 * 4、支持重入
 * 5、不支持锁升级，只能降级。
 * 6、读写锁，读锁不支持条件
 *  读锁的条件直接调用ReentrantReadWriteLock的 newCondition 会直接exception
 *  public Condition newCondition() {
 *     throw new UnsupportedOperationException();
 *  }
 */
public class ReadWriteLock8 {

    // 定义读写锁
    final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    final static Lock r = lock.readLock();
    final static Lock w = lock.writeLock();
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

    /**
     * 读写锁，写锁支持条件
     */
    public void m8() {
        Condition condition = w.newCondition();
        // 写锁
        new Thread(() -> {
            w.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get wirte lock ...");
                try {
                	System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " 即将进入阻塞状态 ...");
                    condition.await();
                    System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " 被唤醒，执行结束 ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                w.unlock();
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            w.lock();
            try {
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " get write lock ...");
                condition.signal();
                System.out.println(getSystemTime() + " Thread " + Thread.currentThread().getName() + " 唤醒了 Thread t1 ...");
            } finally {
                w.unlock();
            }
        },"t2").start();
    }

    private String getSystemTime(){
        return sdf.format(System.currentTimeMillis());
    }

    public static void main(String[] args) throws InterruptedException {
        ReadWriteLock8 rwl = new ReadWriteLock8();
        //8、读写锁，写锁支持条件
        rwl.m8();

    }

}

执行结果：
在这里插入图片描述
  从执行结果来看，线程 t1 获取到写锁，执行相关业务逻辑，调用 Condition 的 await() 方法线程进入阻塞状态，t1 释放写锁，t2 获取写锁，调用 Condition 的 signal() 方法唤醒了阻塞队列中的线程 t1 ，t1 拿到写锁继续执行相关业务逻辑。因此，能证明写锁支持条件。

3、JDK源码中金典案例分析

  以下是JDK源码中的一个金典示例，从示例中可以看出 ReentrantReadWriteLock 的使用场景，可以用作缓存，还从示例中可以分析出读写锁的很多特点，比如，读写互斥、不支持锁升级、支持锁降级等特点。接下来，我们来仔细分析一下其实现。

/**
 * JDK 源码中一个金典例子，缓存数据
 */
class CachedData {
    Object data;
    // 缓存是否过期
    volatile boolean cacheValid;
    // 定义一把读写锁
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    // 处理缓存数据的方法
    void processCachedData() {
        // 先获取读锁
        rwl.readLock().lock();
        // 判断缓存是否过期，如果缓存没有过期则调用 use(data);
        if (!cacheValid) {
            // 如果缓存过期了，要去加载真实数据，set 给缓存

            // 由于锁不能升级，在获取写锁之前必须释放读锁
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // 重新检查状态，因为其他线程可能已经获得写锁并在我们之前更改了状态。
                if (!cacheValid) {
                    // 实际业务操作，加载真实数据
                    // TODO data = ...
                    cacheValid = true;
                }
                // 在释放写锁之前获取读锁来降级，也就是更新缓存之后接着读取 所以先加锁
                rwl.readLock().lock();
            } finally {
                // 释放写锁，保持读
                rwl.writeLock().unlock(); // Unlock write, still hold read
            }
        }

        try {
            //不管上面的if进不进都会执行这里
            //缓存可用
            // TODO use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

4、总结

  通过上面几个示例对读写锁 ReentrantReadWriteLock 的了解，我们知道读写锁的特点大致可以分为以下几种情况， 读读并发、读写互斥、写写互斥、支持锁重入、支持写锁条件、不支持读锁条件、支持锁降级、不支持锁升级。

  思考一下，读写锁为什么不支持升级？支持降级呢？

  通用对读写锁几个重要特点的了解，如果所有的线程都去申请获取读锁的话，是可以多个线程同时申请读锁成功；如果是申请写锁，那么只能一个线程申请成功，且不可能同时持有读锁和写锁；由于读写锁是互斥锁，线程在申请写锁的时候，需要先等到读锁都释放，才能申请写锁成功。
  假设有 t1，t2 和 t2 三个线程，它们都已持有读锁。假设线程 t1 尝试从读锁升级到写锁。那么它必须等待 t2 和 t3 释放掉已经获取到的读锁。如果随着时间推移，t2 和 t3 由于某种原因逐渐释放了它们的读锁，此时线程 t1 确实是可以成功升级并获取写锁。但是我们考虑一种特殊情况。假设线程 t1 和 t2 都想升级到写锁，那么对于线程 t1 而言，它需要等待其他所有线程，包括线程 t2 在内释放读锁。而线程 t2 也需要等待所有的线程，包括线程 t1 释放读锁。这就是一种非常典型的死锁的情况。谁都愿不愿意率先释放掉自己持有的锁。但是读写锁的升级并不是不可能的，也有可以实现的方案，如果我们保证每次只有一个线程可以升级，那么就可以保证线程安全。只不过最常见的 ReentrantReadWriteLock 对此并不支持。但是锁降级是可以的，因为写锁只有一个线程占有，所以这个时候利用锁的降级是很好的办法，可以提高系统的整体性能。

// 定义读写锁
final static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.sss");

/**
 * 读写锁为什么不能升级？接下来分析以下代码逻辑
 * 结论：会产生死锁
 */
private void test(){
    // 读锁
    lock.readLock().lock(); // 假设有 t1，t2 和 t2 三个线程，它们都已持有了读锁。
    // TODO ; // 比如线程 t1 在执行相关业务逻辑的过程中，线程 t2 t3 来了，获取了读锁，此时三个线程都获取了读锁
    /**
     * 1、假设线程 t1 尝试从读锁升级到写锁。那么它必须等待 t2 和 t3 释放掉已经获取到的读锁。
     * 如果随着时间推移，t2 t3 由于某种原因逐渐释放了它们的读锁，此时线程 t1 确实是可以成功升级并获取写锁。
     *
     * 2、假设线程 t1 和 t2 都想升级到写锁，那么对于线程 t1 而言，它需要等待其他所有线程，包括线程 t2 在内释放读锁。
     * 而线程 t2 也需要等待所有的线程，包括线程 t1 在内释放读锁。谁都不愿意释放掉自己持有的锁，这就是一种非常典型的死锁的情况。
     *
     */
    lock.writeLock().lock(); // t1 等待 t2 和 t3 释放读锁，t2 等待 t1 和 t3 释放读锁
    // TODO ;
    lock.writeLock().unlock();
    lock.readLock().unlock();
}

备注：博主微信公众号，不定期更新文章，欢迎扫码关注。
在这里插入图片描述

菜鸟技术栈
关注
专栏目录
Java多线程编程之读写锁ReadWriteLock用法实例
09-03
主要介绍了Java多线程编程之读写锁ReadWriteLock用法实例,本文直接给出编码实例,需要的朋友可以参考下
6、JDK并发锁之读写锁
zhen_hong的博客
11-09 307
一、前言     前一节我们分析了AQS并发框架和独占锁以及condition的实现，为我们继续往下分析并发包中其他的类打下了基础，现在我们趁热打铁，分析一下读写锁。 二、基础 2.1 类图 ReadWriteLock：定义了两个接口方法，获取读锁和写锁 Sync：ReentrantReadWriteLock的内部类，实现了AQS框架的基本方法，定义了一...
ReentrantReadWriteLock读写锁简单示例
一点博客
12-05 399
一、读写锁简介 使用场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源（共享锁）；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了（排它锁）； 针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁，描述如下： 线程进入读锁的前提条件： 没有其他线程的写锁， 没有写
jdk读写锁
oneFaceThick的博客
08-05 190
误区： 读写锁公平读锁抢占的时候，是去判断，队列中的第一个是不是写锁，如果是，那么就写入。 公平不公平其实体现在是否要直接抢占，如果前面有写锁，而且被感知，无论公平与否，都会阻塞读锁。 获取写锁后，可以降级为读锁。参照 https://www.jianshu.com/p/cd485e16456e protected final int11 tryAcquireShared(int unused) { Thread current = Thread.currentThread();
JDK5 读写锁 ReadWriteLock
skydream_xu的专栏
08-16 1000
JDK5了Lock对象。而读写锁就是其中的一个优秀的例子。 读写锁：多个读锁不互斥，读锁和写锁互斥，写锁和写锁互斥   面的代码展示了如何利用重入来执行升级缓存后的锁降级（为简单起见，省略了异常处理）： class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock
Java并发编程：读写锁ReentrantReadWriteLock与StampLock解析
"这篇资料主要介绍了Java并发编程中的读写锁ReentrantReadWriteLock以及相关的StampLock，强调了在读多写少的并发场景下，读写锁的优势。内容包括读写锁的基本概念、特性、使用方法，以及ReentrantReadWriteLock的...
Java并发编程：ReentrantLock与ReentrantReadWriteLock深度解析
本文主要介绍了Java并发编程中的JUC（Java Concurrency in Practice）知识点，特别是ReentrantLock和ReentrantReadWriteLock的源码解析。文章着重讲解了ReentrantLock的特性及其与synchronized关键字的不同之处。 ...
Java并发包源码分析(JDK1.8)
06-13
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue...
基于JDK源码解析Java领域中的并发锁之设计与实现.pdf
09-17
本文将基于JDK源码解析Java领域中的并发锁，探讨AQS基础同步器、LockSupport、Condition接口、Lock接口、ReadWriteLock接口以及自定义API操作的设计与实现。 一、AQS（AbstractQueuedSynchronizer）基础同步器的...
Java并发编程之重入锁与读写锁
08-29
Java并发编程之重入锁与读写锁 在 Java 并发编程中，重入锁和读写锁是两个非常重要的概念。...重入锁和读写锁是 Java 并发编程中非常重要的概念，正确地使用它们可以提高并发性能，避免死锁和其他并发问题。
浅谈 JDK 的读写锁——ReentrantReadWriteLock
Shawearn
04-11 668
从 JDK1.5 开始，JDK 加入了 ReentrantLock 类，该类能够像 synchronized 关键字一样实现线程之间的同步互斥，并且在功能上比 synchronized 更强大，使用起来也更灵活。 然而，ReentrantLock 在某些情况下也有自身的不足，因为同一时间内只有一个线程能够获取到锁并执行，这虽然保证了线程的安全，但假设我们有多个线程只是需要对对象进行读取操作，并没...
jdk读写锁ReentrantReadWriteLock
不说话装高手
06-19 262
public ReentrantReadWriteLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); readerLock = new ReadLock(this); writerLock = new WriteLock(this); }   构造方法中会生成读锁和写锁。   ...
10.JDK并发包-同步控制之读写锁(ReadWriteLock)
写后端的小学生
04-03 911
读写分离锁可以有效地减少锁竞争，以提高系统性能。
阅读 JDK 源码：读写锁 ReentrantReadWriteLock
Sumkor的博客
05-01 883
在 JUC 包中，共享锁包括 CountDownLatch、CyclicBarrier、Semaphore 等。ReentrantReadWriteLock 是基于 AQS（AbstractQueuedSynchronizer）框架实现的锁工具，其中定义了两个锁：共享锁 readLock 和独占锁 writeLock。readLock 用于读操作，能同时被多个线程获取；writeLock 用于写入操作，只能被一个线程持有。读锁、写锁均具有公平模式、非公平模式两种获取锁的方式。
(六)JDK源码分析之可重入读写锁ReentrantReadWriteLock
weixin_38312719的博客
12-14 210
概述 可重入读写锁,其实就是在重入锁基础上区分了一下读写锁.读写锁也称为共享锁,也就是说可以多个线程同时获取锁,这样大大提高了系统的吞吐量. 读写锁中 读锁和读锁是共享的,写锁和读锁写锁都是互斥的. 锁的状态如何区分读写锁 我们经过前面分析,知道在同步器中,用了一个int型来表示一个状态,当这个int值不为0时,说明这个时候锁是被获取了的,这个时候其他线程只能自旋等待, 当然到了读写锁也...
java 自己实现 ReadWriteLock （一）
yoyoyao的专栏
04-27 1166
多线程读写同一个对象的数据是很普遍的，通常，要避免读写冲突，必须保证任何时候仅有一个线程在写入，有线程正在读取的时候，写入操作就必须等待。简单说，就是要避免“写-写”冲突和“读-写”冲突。但是同时读是允许的，因为“读-读”不冲突，而且很安全。要实现以上的ReadWriteLock，简单的使用synchronized就不行，我们必须自己设计一个ReadWriteLock类，在读之前，
【java】读写锁 ReadWriteLock 实现
比嗨皮兔
03-08 803
原理 读写锁原理很简单，里面使用AQS来实现读写锁，但是对AQS了解的朋友应该都知道，AQS只有一个互斥(同步)资源state，那怎么实现的呢，其实是使用state类型是int类型，是32位的，所以利用高低16位分别用作读写的标志，而且读写锁是可重入的。 总结下来就是： 读读不互斥； 读写互斥； 写写互斥； 可重入锁。 特别注意 读写锁是可以降级的，就是加了读/写锁的功能里面是可以再次加读锁的；反之则不可以，就是读/写锁的功能模块里面，若是锁没有释放，是不可以加写锁的，必须释放之后才能加写锁。 示例代码
ReadWriteLock:JAVA自带的读写锁
yeluowan的博客
09-08 271
ReadWriteLock:简单使用
jdk1.5——readLock/writeLock
后知后觉的it路
10-19 188
    1 关于读写锁的一些特点：   a) 读写锁是JVM自己控制的，我们只要上相应方法上加锁即可   b) 多个读锁共享数据/操作   c) 读锁和写锁行为互斥   d) 写锁和写锁行为互斥       2 读写锁应用案例1， package thread; import java.util.Random; import java.util.concurren...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值