微调Java同步块行为

Question

我有两个同步的代码块。 我需要两个代码块不能在两个或多个不同的线程中同时运行，但是我想允许两个或多个不同的线程同时运行一个代码块。 用Java如何做到这一点？ 举例说明：

class HelloWorld {

    method1() {
        synchronized (?) { //block 'A'
            //I want to allow 2+ threads to run this code block simultaneously
        }
    }

    method2() {
        synchronized (?) { //block 'B'
            //this should block while another thread is running
            //the synchronized block 'A'
        }
    }

我不希望两个同步块都锁定在同一对象/类上，因为这将不允许第一个块同时由多个线程运行。 但是，这是防止块A和B由2个或更多线程同时运行的唯一方法。 必须有一种方法来实现这一目标。

Answer 1

我建议分别研究ReadWriteLock实现类ReentrantReadWriteLock 。 那个东西特别是被设计成允许多个 “阅读器”线程。 但只有一个 “作家”线程。

如果我正确阅读了您的问题，那正是您所要的。 另一方面，退后一步并阐明您要在此处解决的真正问题可能也是明智的。

特别是考虑到上述锁在Java8上可以很好地工作，但是在Java的早期版本中却遇到了问题。

Answer 2

也许像这样：

private CommonStateSynchronizer synchronizer = new CommonStateSynchronizer();

public void method1() throws InterruptedException
{
    synchronizer.run("method1", () -> {
        // do method1
    });
}

public void method2() throws InterruptedException
{
    synchronizer.run("method2", () -> {
        // do method2
    });
}

public static class CommonStateSynchronizer
{
    private final ReentrantReadWriteLock rw;
    private final ReentrantReadWriteLock.ReadLock r; // hold read lock while executing in current state
    private final ReentrantReadWriteLock.WriteLock w; // hold write lock while checking or changing state
    private final Condition stateChanged;
    private volatile String currentState; // do not modify unless holding write lock

    public CommonStateSynchronizer()
    {
        rw = new ReentrantReadWriteLock(true);
        r = rw.readLock();
        w = rw.writeLock();
        stateChanged = w.newCondition();
    }

    public void run(String state, Runnable runnable) throws InterruptedException {
        w.lock();

        while (!state.equals(currentState))
        {
            if (currentState == null)
            {
                currentState = state;
                stateChanged.notifyAll();
                break;
            }
            stateChanged.await();
        }
        assert state.equals(currentState);

        // downgrade to concurrent read lock
        r.lock();
        w.unlock();

        try
        {
            runnable.run();
        }
        finally
        {
            r.unlock();
            w.lock();

            if (rw.getReadLockCount() == 0)
            {
                currentState = null;
                stateChanged.notifyAll();
            }
            w.unlock();
        }
    }
}