当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


Java ReentrantReadWriteLock用法及代码示例


Java 的 ReentrantReadWriteLock 类是 ReadWriteLock 的实现,它也支持 ReentrantLock 函数。

ReadWriteLock 是一对关联锁,一个用于只读操作,一个用于写入操作。而 ReentrantLock 是一个可重入互斥锁,其行为与使用同步方法和语句访问的隐式监视器锁相同,但具有一些更多的扩展函数。

Java 中的ReadWriteLock

即使在多线程应用程序中,共享资源也可能同时发生多个读取。只有当多个写入同时发生或读写混合时,才有可能写入错误值或读取错误值。

Java 中的 ReadWriteLock 使用相同的想法,通过使用单独的锁对来提高性能。 ReadWriteLock 维护一对关联的锁 -

  1. 一个用于只读操作;和
  2. 一个用于写作。

只要没有写入者,读取锁就可以由多个读取者线程同时持有。写锁是独占的。

拥有一对 read-write lock 可以在访问共享数据时实现比互斥锁更高级别的并发性。它利用了这样一个事实:虽然一次只有一个线程(写入线程)可以修改共享数据,但在许多情况下,任意数量的线程可以同时读取数据(因此是读取线程)。

如果读取的频率大于写入的频率、读取操作的持续时间大于写入的持续时间,则读写锁将比使用互斥锁提高性能。它还取决于数据的争用,即尝试同时读取或写入数据的线程数量。

包资源管理器视图

• java.lang.Object
    • java.util.concurrent.locks.ReentrantReadWriteLock

用法:导入类

public class ReentrantReadWriteLock
extends Object
implements ReadWriteLock, Serializable

构造函数总结

  1. ReentrantReadWriteLock():创建具有默认(非公平)排序属性的新ReentrantReadWriteLock。
  2. ReentrantReadWriteLock(boolean fair):使用给定的公平策略创建一个新的ReentrantReadWriteLock。

抛出异常:

执行:

我们将创建三个 Runnable 实现。它们都使用ReentrantReadWriteLock 锁定变量。该锁是使用 ReentrantReadWriteLock(boolean fair) 构造函数创建的,因此它被赋予了公平策略:

  • 读得到锁。它使用ReentrantReadWriteLock的readLock() API方法来获取ReadLock。然后,它使用ReadLock的lock()方法获取读锁。在获得锁的同时,它读取字符串消息变量的值。然后它尝试使用 ReadLock 的 unlock() 方法释放锁。
  • WriteA 和 WriteB 也都获得锁,使用 writeLock() 方法返回一个 WriteLock,然后使用 WriteLock 的 unlock() 方法。由于具有写锁,它们都改变了字符串消息变量的值。然后,他们使用 WriteLock 的 unlock() 方法释放写锁。

示例

Java


// Java Program to Illustrate ReentrantReadWriteLock Class
// Importing ReentrantReadWriteLock
// fro java.util package
import java.util.concurrent.locks.ReentrantReadWriteLock;
// Class 1
// Main class
public class ReentrantReadWriteLockExample {
    private static final ReentrantReadWriteLock lock
        = new ReentrantReadWriteLock(true);
    // Initially the string contains only 1 character
    private static String message = "a";
    // Main driver method
    public static void main(String[] args)
        throws InterruptedException
    {
        // Creating threads
        Thread t1 = new Thread(new Read());
        Thread t2 = new Thread(new WriteA());
        Thread t3 = new Thread(new WriteB());
        // Starting threads with help of start() method
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
    }
    // Class 2
    // Helper class implementing Runnable interface
    static class Read implements Runnable {
        // run() method for thread
        public void run()
        {
            for (int i = 0; i <= 10; i++) {
                if (lock.isWriteLocked()) {
                    System.out.println(
                        "I'll take the lock from Write");
                }
                // operating lock()
                lock.readLock().lock();
                System.out.println(
                    "ReadThread "
                    + Thread.currentThread().getId()
                    + "Message is " + message);
                lock.readLock().unlock();
            }
        }
    }
    // Class 3
    // Helper class implementing Runnable interface
    static class WriteA implements Runnable {
        // run() method for thread
        public void run()
        {
            for (int i = 0; i <= 10; i++) {
                // Try block to check fr exceptions
                try {
                    lock.writeLock().lock();
                    message = message.concat("a");
                }
                finally {
                    lock.writeLock().unlock();
                }
            }
        }
    }
    // Class 4
    // Helper class implementing Runnable interface
    static class WriteB implements Runnable {
        // run() method for thread
        public void run()
        {
            for (int i = 0; i <= 10; i++) {
                // Try block to check for exceptions
                try {
                    lock.writeLock().lock();
                    message = message.concat("b");
                }
                finally {
                    lock.writeLock().unlock();
                }
            }
        }
    }
}
输出
ReadThread 11 ---> Message is a
ReadThread 11 ---> Message is aba
ReadThread 11 ---> Message is ababa
ReadThread 11 ---> Message is abababa
ReadThread 11 ---> Message is ababababa
ReadThread 11 ---> Message is abababababa
ReadThread 11 ---> Message is ababababababa
ReadThread 11 ---> Message is abababababababa
ReadThread 11 ---> Message is ababababababababa
ReadThread 11 ---> Message is abababababababababa
ReadThread 11 ---> Message is ababababababababababa


相关用法


注:本文由纯净天空筛选整理自praveen13kulkarni大神的英文原创作品 ReentrantReadWriteLock Class in Java。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。