java - ReentrantLock - 在被调用的方法中解锁

Question

重入锁

void a() {

    lock.lock();    //got intrinsic lock 
    System.out.println(Thread.currentThread().getName());
    System.out.println("In A");
    b();            // called method in synchronized block

    Thread.sleep(2000);    // sleeping current thread(avoided try catch for simplicity) 


    System.out.println("after calling method B()");
    System.out.println(Thread.currentThread().getName());

    lock.unlock();    // releasing intrinsic lock

}

void b() {

    lock.lock();// getting intrinsic lock, no problem as calling thread already has intrinsic lock 
    System.out.println(Thread.currentThread().getName());
    System.out.println("In B");
    lock.unlock();    // intentionally releasing lock, so now there is no lock .

        Thread.sleep(2000);
}

生成了两个线程，线程 0 和线程 1 都在调用 a()。

在 a() 中，我获得了内在锁，然后我调用了 b()。在 b() 中，我也获得了内部锁，所以我将获得当前线程拥有的相同锁。现在我有意在 b() 中解锁，它释放了锁，以便其他等待线程可以获得锁，只是为了确保我什至让当前线程 sleep 。当我的线程在 b() 中 hibernate 2000 毫秒而不是在 a() 中 hibernate 2000 毫秒时，我期望其他线程将通过获取已释放的锁来运行 a()。

但它并没有按照我的输出发生

输出:-

Thread-0
In A
Thread-0
In B
after calling method B()
Thread-0
Thread-1
In A
Thread-1
In B
after calling method B()
Thread-1

Answer 1

Now I'm intentionally unlocking in b() which releases the lock so that other waiting thread could get the lock

不，它并没有完全释放它——它只是减少了锁定计数。在调用 unlock 之前，您调用了 lock 两次，因此保持计数为 2。在调用 unlock 之后>，持有计数为 1，所以它仍然阻止其他线程获取锁。基本上，您的代码有点像:

void a() {
    synchronized (foo) {
        b();
    }
}

void b() {
    synchronized(foo) {
        // In here, the count is 2
    }
    // Now the count is still 1...
}