等待/通知的无锁变体

Question

在调用o.wait() 或o.notify() 之前，Java 需要一个线程拥有o 的监视器。这是众所周知的事实。但是，任何此类机制都需要互斥锁才能正常工作吗？如果有提供的 API 会怎样

compareAndWait

和

setAndNotify

相反，将 CAS 操作与线程调度/取消调度相结合？这会有一些好处：

• 即将进入等待状态的线程不会阻碍通知线程的进度；

• 他们也不必在被允许检查等待条件之前互相等待；

• 在通知端，任意数量的生产者线程可以同时进行。

提供这样的 API 是否存在根本的、不可克服的障碍？

Answer 1

使用LockSupport.park() 和LockSupport.unpark(Thread) 实现任意等待/通知机制没有问题，因为这些基本原语不需要持有任何锁。

Object.wait/Object.notify 和 Condition.await/Condition.signal 在没有锁定的情况下向您提供这样的通知的原因是语义。通知的概念是一个线程等待一个条件被满足，而另一个线程在条件变为满足状态时停止等待。如果不持有与该条件关联的锁，则无法保证条件在测试条件状态和线程状态更改之间不会发生变化。

更具体地说，当一个更改条件的线程通知另一个线程时，可能会在通知发生之前再次修改条件。但更糟糕的是，条件可能会在线程开始到 wait 之前更改为“已完成”，在这种情况下，线程可能会错过通知并永远挂起。

即使你能够将条件测试和等待操作融合为一个原子操作，也无济于事。等待一个条件本身并不是目的。线程想要等待条件的原因是它想要执行以条件为先决条件的动作，因此在执行动作时不能改变。这就是重点：条件测试和操作必须作为一个持有锁的操作来实现，而不管锁的概念是如何实现的。

在某些特殊情况下不会出现此类问题，例如当已知条件的状态转换是有限的时，您可以排除条件可以返回到未完成的状态。这正是CountDownLatch、CyclicBarrier、Phaser 等工具的用途，但具有预定义的等待/通知语义的通知机制意味着不假设这种特殊情况。

Answer 2

比一些真正的工作代码更像是一个思想实验，但这似乎有效。

// My lock class.
public static class Padlock<E extends Enum<E>> {

    // Using Markable because I think I'm going to need it.
    public final AtomicReference<E> value;
    // Perhaps use a set to maintain all waiters.
    Set<Thread> waiters = ConcurrentHashMap.newKeySet();

    public Padlock(E initialValue) {
        this.value = new AtomicReference<>(initialValue);
    }

    /**
     * Waits for the locks value to become the specified key value.
     *
     * @param waitFor - The desired key.
     */
    public void compareAndWait(E waitFor) {
        log("Wait for " + waitFor);
        // Spin on the value.
        while (value.get() != waitFor) {
            log("Park waiting for " + waitFor);
            // Remember me as waiting.
            waiters.add(Thread.currentThread());
            // TODO: What do we do here??
            LockSupport.park();
            log("Awoke " + waitFor);
        }
    }

    /**
     * Sets the locks value to the key value.
     *
     * If this resulted in a change - notify all changers.
     *
     * @param shouldBe - What it should be now.
     * @param makeIt - The new value to set.
     */
    public void setAndNotify(E shouldBe, E makeIt) {
        log("Set " + shouldBe + "->" + makeIt);
        if (value.compareAndSet(shouldBe, makeIt)) {
            log("Notify " + shouldBe + "->" + makeIt);
            // It changed! Notify the waiters.
            for (Thread t : waiters) {
                // Perhaps
                log("Unpark " + t.getName());
                LockSupport.unpark(t);
            }
        }
    }
}

enum State {

    Off, On;
}

private static final long TESTTIME = 30000;
private static final long TICK = 100;

private static final void log(String s) {
    System.out.println(Thread.currentThread().getName() + ": " + s);

}

static class MutexTester implements Runnable {

    final Padlock<State> lock;

    public MutexTester(Padlock<State> lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        Thread.currentThread().setName(this.getClass().getSimpleName());
        long wait = System.currentTimeMillis() + TESTTIME;
        do {
            // Wait for an On!
            lock.compareAndWait(Test.State.On);
            try {
                log("Got it!");
                try {
                    Thread.sleep(TICK);
                } catch (InterruptedException ex) {
                    log("Interrupted!");
                }
            } finally {
                // Release
                lock.setAndNotify(Test.State.On, Test.State.Off);
            }
        } while (System.currentTimeMillis() < wait);
        log("Done");
    }
}

static class RandomSwitcher implements Runnable {

    final Padlock<State> lock;
    final Random random = new Random();

    public RandomSwitcher(Padlock<State> lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        Thread.currentThread().setName(this.getClass().getSimpleName());
        long wait = System.currentTimeMillis() + TESTTIME;
        do {
            // On!
            lock.setAndNotify(Test.State.Off, Test.State.On);
            log("On!");
            pause();
            lock.setAndNotify(Test.State.On, Test.State.Off);
            log("Off!");
            pause();
        } while (System.currentTimeMillis() < wait);
        log("Done");
    }

    private void pause() {
        try {
            // Random wait.
            Thread.sleep(TICK * random.nextInt(10));
        } catch (InterruptedException ex) {
            System.out.println("Interrupted! " + Thread.currentThread().getName());
        }
    }
}

public void test() throws InterruptedException {
    final Padlock<State> lock = new Padlock<>(State.Off);
    Thread t1 = new Thread(new MutexTester(lock));
    t1.start();
    Thread t2 = new Thread(new RandomSwitcher(lock));
    t2.start();
    t1.join();
    t2.join();
}

我已经实现了compareAndWait 等待独占使用而setAndNotify 释放互斥锁的协议。

Answer 3

首先，Java 的内置监视器（synchronized 和 wait）比许多人想象的要高效。请参阅biased locking，并计划进一步改进以利用硬件事务内存。

其次，您正在寻找的机制与synchronized/wait 提供的机制有不同的用途。后者保护一些受保护的资源，并且必须包含一个锁，因为它假定在wait 之后您希望进入临界区。您正在寻找的内容由其他 Java 并发原语提供，例如 CountDownLatch、Phaser 或 Semaphore。