在 Java 中为一个同步/锁定使用不同的对象

Question

我有两个不同的对象，但是 它们是相等的 (obj1 != obj2, but obj1.equlas(obj2))

我怎样才能对这个对象使用同步/锁定？ 例如：

...
synchronized(obj) {
        doSomething(obj);
}
...

如果 equals() 对象之一已经在同一时间做某事，我想锁定它。

Answer 1

没有办法只使用一个同步（对象）并使两个对象同步。

解决办法是：

synchronized (obj) {
      synchronized (obj2) { ......

但如果你在另一个线程中颠倒顺序，你会得到一个死锁。

或者我建议的另一种解决方案是使您的 obj 静态并用于同步。

你所拥有的是有意义的等于对象，但是你对 obj 和 obj2 的变量引用指向不同的对象。

Answer 2

我不能说我完全理解为什么需要这样做，但使用包装器方法可能可能会有所帮助：

public class SyncOnEquals {
    public synchronized Object getSync(Object o1, Object o2)
    {
        if(o1.equals(o2))
            return this;
        else
            return o1;
    }
}

测试：

@org.junit.Test
public void testSyncOnEqual() {
System.out.println("syncOnEqual");
Integer o1 = new Integer(125);
Integer o2 = new Integer(125);

System.out.println("o1 == o2: "+(o1==o2));
System.out.println("o1.equals(o2): "+o1.equals(o2));
SyncOnEquals sync = new SyncOnEquals();

Thread t1 = new Thread(){
    public void run()
    {
        System.out.println("Waiting thread "+Thread.currentThread());
        synchronized(sync.getSync(o1, o2))
        {
            System.out.println("Working thread "+Thread.currentThread());
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("Finished thread "+Thread.currentThread());
    }
};

Thread t2 = new Thread(){
    public void run()
    {
        System.out.println("Waiting thread "+Thread.currentThread());
        synchronized(sync.getSync(o2, o1))
        {
            System.out.println("Working thread "+Thread.currentThread());
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("Finished thread "+Thread.currentThread());
    }
};

t1.start();
t2.start();

try{
    Thread.currentThread().sleep(2000);
} catch (InterruptedException ex) {
    ex.printStackTrace();

    }
}

输出：

syncOnEqual
o1 == o2: false
o1.equals(o2): true
Waiting thread Thread[Thread-0,5,main]
Waiting thread Thread[Thread-1,5,main]
Working thread Thread[Thread-0,5,main]
Finished thread Thread[Thread-0,5,main]
Working thread Thread[Thread-1,5,main]
Finished thread Thread[Thread-1,5,main]