Question

想象一下有三种方法的Java类：

master()
foo()
bar()

我希望同步master()和foo()以及master()和bar()，而无需同步foo()和bar()。它可以为每对同步方法单独锁定，但我的实际代码有三个以上的方法，所以我希望有一种方法可以在没有这么多锁定对象的情况下完成它。

Answer 1

您实际上是在描述ReadWriteLock。允许每两个方法同时运行（“读锁定”），public class MyClass { private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); private final Lock r = rwLock.readLock(); private final Lock w = rwLock.writeLock(); public void master() { w.lock(); // do stuff w.unlock(); } public void foo() { r.lock(); // do stuff r.unlock(); } public void bar() { r.lock(); // do stuff r.unlock(); } }除外，它排除所有其他方法（“写锁定”）：

AVCaptureSession

Answer 2

您可以在任何Object上使用public class Lock { private final Object master_foo = null; private final Object master_bar = null; public void master() { synchronized(master_foo) { synchronized(master_bar) { ... } } } public void foo() { synchronized(master_foo) { ... } } public void bar() { synchronized(master_bar) { ... } } }。因此，您可以为方法创建单独的锁：

train_data = treebank.tagged_sents()[:3523]
test_data = treebank.tagged_sents()[3523:]
hmm_pos_tagger = hmm.HiddenMarkovModelTagger.train(train_data)
print('HMM = %0.5f' % hmm_pos_tagger.evaluate(test_data))

output = open('tagger_hmm.pickle', 'wb', -1)
pickle.dump(hmm_pos_tagger, output)
output.close()

Answer 3

我会选择Mureinik的回答，但只是为了它，这是另一种设置读/写同步（未经测试）的方法：

public class Test {

    private final Semaphore semaphore = new Semaphore(Integer.MAX_VALUE);

    public void master() {
        semaphore.acquireUninterruptibly(Integer.MAX_VALUE);
        try {
            //...
        } finally {
            semaphore.release(Integer.MAX_VALUE);
        }
    }

    public void foo() {
        semaphore.acquireUninterruptibly();
        try {
            //...
        } finally {
            semaphore.release();
        }
    }

    public void bar() {
        semaphore.acquireUninterruptibly();
        try {
            //...
        } finally {
            semaphore.release();
        }
    }

}

同步重叠的方法集

3 个答案: