1

我有一个用例，我想将复杂的计算分成两部分（以两种不同的方法）并同时计算它们。换句话说，我会有这样的课程：

class A 

public synchronized double computeOne {****};

public synchronized double computeTwo {****};

我是否可以启动两个线程，并让 threadA 运行 computeOne，threadB 运行 computeTwo（一个与 classA 相同的实例）？

我觉得这行不通，因为只有一种方法可以在 A 类的特定实例中获取监视器。

那么......我怎样才能通过并发功能实现我的目标？

4

2 回答 2

3

您不必在对象上使用锁，您可以指定单独的锁：

class A {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public double computeOne {
        synchronized(lock1) {
            ****
        }
    }

    public double computeTwo {
        synchronized(lock2) {
            ****
        }
    } 
}

这假设这两种方法不会通过篡改其他方法使用的状态而相互干扰。您想同时调用这些东西表明该对象可能会被重新设计并拆分为具有更集中责任的单独对象。

无论如何，在内部锁上同步是一种推荐的做法，因此不仅仅是任何东西都可以出现并获取锁。

如果您可以从计算中删除任何状态，这样您就可以完全避免锁定，这将是更可取的。如果唯一的状态是该方法的本地状态，那么您不必锁定。

于 2013-10-24T15:36:10.520 回答
1

Nathan 使用 java.util.concurrent 的代码

    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;

public static class A {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public void computeOne() {
        try {
            lock1.lock();
            // your code
        } finally {
            lock1.unlock();
        }
    }

    public void computeTwo() {
        try {
            lock2.lock();
            // your code
        } finally {
            lock2.unlock();
        }
    }
}
于 2013-10-24T15:40:20.750 回答