Question

有人问我这个问题而且我无法找到解决方案，我有一个方法A和a1的课程a2：

Class A {a1() a2()}：

以及使用方法B和b1：

的课程b2

Class B {b1() b2()}

考虑到多线程环境，我想在调用a1时停止执行b1，同样适用于b2和a2。两个对象都是独立的。这可能吗？

Answer 1

public class A {
    private final Object lock;

    public A(Object lock) {
        this.lock = lock;
    }

    public void a1() { 
        synchronized(lock) {
            ...
        }
    }
}

public class B {
    private final Object lock;

    public B(Object lock) {
        this.lock = lock;
    }

    public void b1() { 
        synchronized(lock) {
            ...
        }
    }
}

现在，如果构造A和B并将它们传递给相同的锁对象，则这两个对象的a1()和b1()方法将是互斥的：

Object lock = new Object();
A a = new A(lock);
B b = new B(lock);

如果希望a2()和b2()互斥，则传递另一个锁定对象，并使这两个方法在另一个锁定对象上同步。

Answer 2

我在blog中试了一下。我希望它有所帮助

这里的想法是创建课程C和D，如下所示

class C {

    static A a = new A(); //I have created new instances of A and B
    static B b = new B(); //The same instances can be passed to C and D via constructor

    static synchronized void da1() {
        a.a1();
    }

    static synchronized void db1() {
        b.b1();
    }
}

class D {

    static A a = new A();
    static B b = new B();

    static synchronized void ca2() {
        a.a2();
    }

    static synchronized void cb2() {
        b.b2();
    }
}

如果您考虑A的{{1}}和a1()的{{1}}应该互斥的情况，那么您应该将它们重定向到{{1 }}

在B中，两个方法都是b1()，这意味着在任何时刻只能执行一个方法（lock是C对象本身）。因此，当执行C时，执行static synchronized的线程将等待，反之亦然。

从其他类方法限制方法执行

2 个答案: