StampedLock.writeLock()是否释放当前线程持有的读取锁? [英] Does StampedLock.writeLock() release a read-lock held by the current thread?

问题描述

http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/包含以下代码:

  StampedLock锁= new StampedLock();长戳= lock.readLock();尝试 {如果(count == 0){邮票= lock.tryConvertToWriteLock(stamp);如果(邮票== 0L){System.out.println(无法转换为写锁");戳= lock.writeLock();}计数= 23;}System.out.println(count);} 最后 {lock.unlock(stamp);} 

作者写道:

调用 tryConvertToWriteLock()不会阻止，但可能会返回零标记，表明当前没有可用的写锁.在这种情况下，我们调用 writeLock()来阻止当前线程，直到有写锁可用为止.

关于 tryConvertToWriteLock()失败的情况，我是否错过了某些事情，还是作者获得了读锁，然后是写锁，却从未释放过读锁?>

此外，是否 lock.writeLock()死锁不会等待当前线程释放其读锁?

解决方案

我认为本文提供的代码示例有问题.根据 https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/locks/StampedLock.html

类似于信号量，但不同于大多数Lock实现，StampedLocks 没有所有权概念.在一个线程中获取的锁可以释放或在另一个线程中转换.

此外，他们提供了以下示例代码:

  void moveIfAtOrigin(double newX，double newY){//升级//而是可以从乐观而非阅读模式开始长戳= sl.readLock();尝试 {而(x == 0.0&&y == 0.0){长ws = sl.tryConvertToWriteLock(stamp);如果(ws！= 0L){戳= ws;x = newX;y = newY;休息;}别的 {sl.unlockRead(stamp);stamp = sl.writeLock();}}} 最后 {sl.unlock(stamp);}} 

在获取写锁之前，请注意他们如何释放读锁.

http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/ contains this code:

StampedLock lock = new StampedLock();
long stamp = lock.readLock();
try {
  if (count == 0) {
    stamp = lock.tryConvertToWriteLock(stamp);
    if (stamp == 0L) {
      System.out.println("Could not convert to write lock");
      stamp = lock.writeLock();
    }
    count = 23;
  }
  System.out.println(count);
} finally {
  lock.unlock(stamp);
}

The author writes:

Calling tryConvertToWriteLock() doesn't block but may return a zero stamp indicating that no write lock is currently available. In that case we call writeLock() to block the current thread until a write lock is available.

Regarding the case where tryConvertToWriteLock() fails, did I miss something or is the author acquiring a read-lock, followed by a write-lock, and never releasing the read-lock?

Further, won't lock.writeLock() deadlock waiting for the current thread to release its read-lock?

解决方案

I believe the code sample provided by the article is buggy. According to https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/locks/StampedLock.html

Like Semaphore, but unlike most Lock implementations, StampedLocks have no notion of ownership. Locks acquired in one thread can be released or converted in another.

Further, they provide the following sample code:

void moveIfAtOrigin(double newX, double newY) { // upgrade
    // Could instead start with optimistic, not read mode
    long stamp = sl.readLock();
    try {
        while (x == 0.0 && y == 0.0) {
            long ws = sl.tryConvertToWriteLock(stamp);
            if (ws != 0L) {
                stamp = ws;
                x = newX;
                y = newY;
                break;
            }
            else {
                sl.unlockRead(stamp);
                stamp = sl.writeLock();
            }
        }
    } finally {
        sl.unlock(stamp);
    }
}

Notice how they release the read-lock before acquiring a write-lock.

这篇关于StampedLock.writeLock()是否释放当前线程持有的读取锁?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！