AbstractQueuedSynchronizer.acquireShared即使等待条件已更改也会无限等待

我编写了一个使用AbstractQueuedSynchronizer的简单类。我写了一个代表“门”的类，如果打开，可以传递，如果关闭则可以阻塞。下面是代码：AbstractQueuedSynchronizer.acquireShared即使等待条件已更改也会无限等待

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); 
    } 

};

不幸的是，如果通过方法的线程块，因为门被关闭，其他线程中打开的同时门，堵塞一个不会被中断 - 它会阻止无限。这里是一个测试，显示它：

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(); 
    } 
}

请帮帮忙，我应该怎么改变，使门通过线程成功获取锁。

来源

2012-12-07 zarzyk

你的实现是非常相似的BooleanLatch，在AbstractQueuedSynchronizer的Java的文档提供了protected try*()方法你锁定的政策，我想你需要调用同步。当你打开大门时，释放共享（1） – hoaz

它看起来像setState()只改变状态，但不通知阻止的线程有关更改。

因此，你应该使用获取/释放方法代替：

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

所以，AbstractQueuedSynchronizer整体工作流程看起来像如下：

客户端调用public获取/释放方法
这些方法安排所有同步功能并将实际锁定策略委托给protected try*()种方法
您定义使用getState()/setState()/compareAndSetState()

来源

2012-12-07 14:43:07 axtavt

AbstractQueuedSynchronizer.acquireShared即使等待条件已更改也会无限等待

回答

相关问题