可以在Java對象中顯式鎖定/解鎖隱式同步鎖定

Question

是的，因為它的塊結構，所以同步鎖定語法很容易，但是有時您不能使用它。 有沒有一種方法可以顯式鎖定和解鎖對象上的“同步”監視器，使其與以前使用的“同步”監視器兼容？

class MyObj {
    Object locker_ = new Object();
    void lockedMethod() {
       synchronized(locker_) {
           ....
       }
    }
    Iterator lockTraversal() {
        explicitlyWaitForAndAcquireLock(locker_); // assume will not throw exception
        return(getAnIterator());
    }
    void unlockTraversal() {
        explicitlyReleaselock(locker_);
    }
}


 MyObj obj = (...)

 try {
     Iterator it = obj.lockTraversal();
     for(;;) // iterate 
 } finally {
     obj.unlockTraversal();
 }

當然，在此示例中，“ closures”將消除這種需求，“ stack scoped”析構函數也將消除； ^>但是...

Answer 1

您不能對對象的固有鎖定執行此操作，但可以改用java.util.concurrent.locks.Lock。

如果確實需要它，感到冒險並且不擔心可移植性，則還可以使用misc.sun.Unsafe，特別是monitorEnter和monitorExit。 但是...可能不是一個好主意。

Answer 2

您可以使用ReentrantLock 。

那正是它的作用。

Answer 3

您可以使用ReentrantLock和Condition來發出何時可以釋放鎖的信號。

Answer 4

JVM驗證程序設計為必須平衡鎖定和解鎖。 因此，您不能具有未配對的鎖定和顯式解鎖。

只要您不依賴可重入的行為（對我而言，這似乎一直是個壞主意），您就可以將鎖置於其他線程中。 以線程安全的方式與另一個線程進行通信將確保您獲得相關的事前發生關系。

實現目標的標准方法是Execute Perform習慣用法 ，由javax.swing.text.AbstractDocument.render使用 。

在Java SE 7和更早版本（不是1.0 *）中，Execute Around看起來像：

public interface Traversal<T>() {
    void traverse(Iterator<T> iter);
}
public class MyObj {
    private final Object lock = new Object();
    ...
    public void lockTraversal(Traversal<String> block) {
        synchronized (lock) {
            block.traverse(getAnIterator());
        }
    }
}
MyObj obj = (...)

obj.lockTraversal(new Traversal<String>() {
    public void traverse(Iterator<String> iter) {
        ...
    }
});

從Java SE 8開始，它幾乎是相同的，除了您可以按照以下方式寫點東西：

obj.lockTraversal({iter -> // Guess type of iter.
    ...
});

正如其他人提到的那樣， java.util.concurrent.locks提供了較少約束的鎖。 注意，失去這些約束可能會導致細微的錯誤。 例如，在最初的問題中， lockTraveral拋出可能會導致解鎖lockTraveral而沒有成功的匹配鎖。

Answer 5

Java具有獨立的鎖定框架，從Java 1.5開始，可以在java.util.concurrent.locks包中找到它。 它提供了比synchronized更廣泛的選擇。

class X {
    private final ReentrantLock lock = new ReentrantLock();

    public void m() {
      lock.lock();  // block until condition holds
      try {
        // ... method body
      } finally {
        lock.unlock()
      }
    }
}