为什么线程释放锁后仍然运行？

Question

这是Oracle关于Lock对象的java教程中的例子。请有人确认我是否正确解释了代码。

我将只考虑第一个线程，因为其他线程的工作方式相同。

首先，它获取alphonse的锁，并访问方法impendingBow。该方法现在尝试将两个实例的两个锁分配给线程。如果线程不能同时获得两个锁，它会释放它获得的那个。这是我卡住的时候。如果线程释放锁，另一个线程可以访问这两个实例，并且第一个线程应该在释放锁后立即停止执行。但实际上并没有。它仍然返回布尔值并继续在 bow 方法中运行 else 语句。为什么它可能发生？我认为就像同步代码一样，线程应该停止执行，直到它再次获得锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Random;

public class Safelock {
    static class Friend {
        private final String name;
        private final Lock lock = new ReentrantLock();

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public boolean impendingBow(Friend bower) {
            Boolean myLock = false;
            Boolean yourLock = false;
            try {
                myLock = lock.tryLock();
                yourLock = bower.lock.tryLock();
            } finally {
                if (! (myLock && yourLock)) {
                    if (myLock) {
                        lock.unlock();
                    }
                    if (yourLock) {
                        bower.lock.unlock();
                    }
                }
            }
            return myLock && yourLock;
        }

        public void bow(Friend bower) {
            if (impendingBow(bower)) {
                try {
                    System.out.format("%s: %s has"
                        + " bowed to me!%n",
                        this.name, bower.getName());
                    bower.bowBack(this);
                } finally {
                    lock.unlock();
                    bower.lock.unlock();
                }
            } else {
                System.out.format("%s: %s started"
                    + " to bow to me, but saw that"
                    + " I was already bowing to"
                    + " him.%n",
                    this.name, bower.getName());
            }
        }

        public void bowBack(Friend bower) {
            System.out.format("%s: %s has" +
                " bowed back to me!%n",
                this.name, bower.getName());
        }
    }

    static class BowLoop implements Runnable {
        private Friend bower;
        private Friend bowee;

        public BowLoop(Friend bower, Friend bowee) {
            this.bower = bower;
            this.bowee = bowee;
        }

        public void run() {
            Random random = new Random();
            for (int n = 0; n <5;n++) {
                try {
                    Thread.sleep(Math.round(Math.random()*1000));
                } catch (InterruptedException e) {}
                bowee.bow(bower);
            }
        }
    }


    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new BowLoop(alphonse, gaston)).start();
        new Thread(new BowLoop(gaston, alphonse)).start();
    }
}

Answer 1

同步块之间存在细微差别，Lock.lock()、Lock.tryLock() 和 Lock.tryLock(timeout)。

tryLock 方法只有在调用时没有被另一个线程持有时才会获取锁。所以当它无法获得锁时，它会立即返回。

lock 方法将等待直到锁可用，同时等待该线程处于休眠状态。将代码与同步语句同步也是如此。线程将一直等待，直到它可以获取该代码块上的锁。

tryLock(timeout) 方法将等待直到锁可用或超时到期。

或多或少在 javadoc 中有所描述：https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/Lock.html

对于您期望的行为，您将tryLock 语句更改为lock，您会注意到线程最终会陷入死锁。

Answer 2

线程释放锁时不会停止执行。如果出现以下情况，它将停止执行：

1. 它试图锁定一个锁但不能（不会在此处停止执行，因为您使用了 trylock）
2. 它明确地产生控制，例如通过睡觉 (sleep())
3. 调度程序决定它现在更喜欢另一个线程。出于所有意图和目的，您应该假设这是一个随机事件。

这些事情都不会在这里发生，所以一个线程会继续执行直到 3) 发生。