对于读写锁规则有些疑问？

Question

这个输出结果就是我根据你写的代码输出的。其中线程3为什么在线程1、2读的时候也能进行写呢？

public class CinemaReadWriteLock {

    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
    /**
     * 读锁
     */
    private static final ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
    /**
     * 写锁
     */
    private static final ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();

    /**
     * 读锁：只能多读
     */
    public static void read() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "：获取到了读锁");
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + "：释放了读锁");
        }
    }

    /**
     * 写锁：只能一写
     */
    public static void write() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "：获取到了写锁");
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "：释放了写锁");
            writeLock.unlock();
        }
    }

    public static void main(String[] args) {
        new Thread(CinemaReadWriteLock::read,"1").start();

        new Thread(CinemaReadWriteLock::read,"2").start();

        new Thread(CinemaReadWriteLock::write,"3").start();

        new Thread(CinemaReadWriteLock::write,"4").start();
    }
}

我用的是JDK 11，发现这个现象与JDK 8不一样。

Answer 1

悟空 2020-02-25 02:27:39

我在我电脑运行了你的代码，结果：

1：获取到了读锁

2：获取到了读锁

1：释放了读锁

2：释放了读锁

3：获取到了写锁

3：释放了写锁

4：获取到了写锁

4：释放了写锁

你在你的电脑上用JDK 8 试一试？

• 提问者 小趴菜木木 #1

  我的意思是这个规则是不是只在JDK 8上成立，在JDK 11就不成立了？

• 悟空 回复 提问者 小趴菜木木 #2

  我查了JDK11 的文档，明确写了：尝试获取公平的写锁（非可重入）的线程将阻塞，除非读锁和写锁均处于空闲状态（这意味着没有等待的线程）。
  我看了ReadWriteLock接口的定义：A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing. The read lock may be held simultaneously by multiple reader threads, so long as there are no writers. The write lock is exclusive.
  我认为在这一点上，JDK11和8是一致的。
  你怎么看？
  https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/locks/ReadWriteLock.html

• 提问者 小趴菜木木 回复 悟空 #3

  额，是不是我理解错了。从这个代码示例看，我的理解是：如果线程1、2获取到了读锁后，只要没有释放那么线程3、4的写锁是获取不到的。但是现在我用JDK 11运行后发现线程1、2获取到了读锁后，线程3或4的写锁依旧可以在线程1、2没有释放的时候获取。而JDK 8却与你讲的是一样。
  
  现在我不确定的是，这个读和写分别在两个方法中，线程1、2调用的是读方法，线程3、4调用的是写方法，这个写的方法到底会不会干扰写的方法？

点开查看后面6条评论