java - AbstractQueuedSynchronizer.acquireShared 无限等待，即使等待条件已经改变

Question

我编写了一个使用 AbstractQueuedSynchronizer 的简单类。我写了一个代表“门”的类，如果打开则可以通过，如果关闭则阻塞。这是代码:

public class GateBlocking {

  final class Sync extends AbstractQueuedSynchronizer {
    public Sync() {
      setState(0);
    }

    @Override
    protected int tryAcquireShared(int ignored) {
      return getState() == 1 ? 1 : -1;
    }

    public void reset(int newState) {
      setState(newState);
    }
  };

  private Sync sync = new Sync();

  public void open() {
    sync.reset(1);
  }

  public void close() {
    sync.reset(0);
  }

public void pass() throws InterruptedException {
    sync.acquireShared(1);
  }

};

不幸的是，如果一个线程因为门关闭而在 pass 方法上阻塞，而其他线程同时打开门，被阻塞的线程不会被中断——它会无限阻塞。这是一个显示它的测试:

public class GateBlockingTest {

    @Test
    public void parallelPassClosedAndOpenGate() throws Exception{
        final GateBlocking g = new GateBlocking();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    g.open();
                } catch (InterruptedException e) {
                }
            }
        });


        t.start();
        g.pass();
    }
}

请帮忙，我应该修改什么才能使通过门的线程成功获取锁。

Answer 1

看起来 setState() 只更改状态，但不会将更改通知阻塞的线程。

因此您应该改用获取/释放方法:

@Override
protected boolean tryReleaseShared(int ignored) {
    setState(1);
    return true;
}
...
public void open() {
   sync.releaseShared(1);
}

因此，AbstractQueuedSynchronizer 的整体工作流程如下所示:

• 客户端调用public获取/释放方法

• 这些方法安排所有同步功能并将实际锁定策略委托(delegate)给protected try*() 方法

• 您使用 getState()/setState()/ 在 protected try*() 方法中定义您的锁定策略>compareAndSetState()