Question

我已经阅读了有关使用synchronized的正确方法的类似问题的答案。但是，他们似乎没有解释为什么会出现这个问题。即使我将synchronized添加到我的getValue和setValue方法，我仍然得到如下输出。为什么会这样？

输出：

制作套装

做到了

制作套装

进行制作

获取

做到了

制作套装

制作做得到

组

代码：

package src;

public class StackNode {
private Object value;
private StackNode next;

private final Object lock = new Object();

public StackNode() {
    setValue(null);
    setNext(null);
}

public StackNode(Object o) {
    value = 0;
    next = null;
}

public StackNode(StackNode node) {
    value = node.getValue();
    next = node.getNext();
}

public synchronized Object getValue() {
        System.out.print(" Doing ");
        System.out.println(" get ");
        System.out.flush();
        return value;

}

public  synchronized void setValue(Object value) {
        System.out.print(" making ");
        System.out.println(" set ");
        System.out.flush();
        this.value = value;
}

public synchronized StackNode getNext() {
    return next;
}

public synchronized void setNext(StackNode next) {
    this.next = next;
}
}

测试：

public class TestStackNode {
private final static StackNode node = new StackNode();

    @Test
public void getSetValueTest() throws InterruptedException{
    node.setValue("bad");
    Runnable setValue = new Runnable(){
        @Override
        public void run() {
            node.setNext(new StackNode());
            node.setValue("new");
        }
    };

    Runnable getValue = new Runnable(){
        @Override
        public void run() {
            Assert.assertEquals("new", node.getValue());
        }
    };
    List<Thread> set = new ArrayList<Thread> ();
    List<Thread> get = new ArrayList<Thread> ();
    for (int i = 0; i < 30000; i++){
        set.add( new Thread(setValue));
        get.add(new Thread(getValue));
    }

    for (int i = 0; i < 30000; i++){
        set.get(i).start();
        get.get(i).start();
    }

    for (int i = 0; i < 30000; i++){
        set.get(i).join();
        get.get(i).join();
    }
}

Answer 1

这应解决问题。

public Object getValue() {
  synchronized(System.out){
    System.out.print(" Doing ");
    System.out.println(" get ");
    System.out.flush();
    return value;
  }

}

Answer 2

问题是你的no-arg构造函数在新创建的实例上调用setValue(...)：

public StackNode() {
    setValue(null);
    setNext(null);
}

并且您的Runnable setValue构建了StackNode的新实例，以传递给node.setNext(...)：

            node.setNext(new StackNode());

（即使你的测试从未真正使用过node.next，所以除了它产生的输出外，这基本上是一个无操作）。由于您的synchronized方法是实例方法（不是static方法），因此它们具有单独的锁，这意味着在新实例的构造函数中调用setValue(...)与您在node上进行的通话不同步。

请注意，虽然您的特定问题相当罕见（您有一个getter和setter正在操作共享外部状态，即System.out，但没有任何相应的共享锁以防止干扰），它实际上是除非方法为private或final或static或类为final，否则始终从构造函数调用方法是个坏主意，因为在完全创建子类实例之前调用了超类构造函数，所以如果构造函数调用在子类中重写的方法，则子类方法将收到一个不完整的this对象，并且可能行为异常严重。最好将构造函数更改为：

public StackNode() {
    value = null;
    next = null;
}

（或者只是完全删除赋值语句，因为引用类型的字段无论如何都会自动初始化为null。）

如何在Java中选择要锁定的对象？

2 个答案: