java - 是否可以使用 volatile 变量来实现一致的只写同步？

Question

是否可以使用 volatile 变量来实现一致的只写同步？

这是代码:

public class Controller {

    Container cont = new Container();
    ...

    public Object get(){
        if(!cont.isLocked()){
            return cont.getObject(); //many threads can read at the same time
        }
        else synchronized(cont){
            return cont.getObject(); //threads wait until write is finished
        }
    }

    public void set(Object o){
        synchronized(cont){
            cont.lock();
            cont.setObject(o);
            cont.unlock();
        }
    }
}

public class Container {
    private volatile boolean lock = false;
    private Object data;

    public Container(){
            }

    public void lock() {
        lock = true;
    }

    public void unlock() {
        lock = false;
    }

    public boolean isLocked() {
        return lock;
    }

    public void setObject(Object o) {
        data = o;
    }

    public Object getObject() {
        return data;
    }
}

它会起作用还是会坏掉，你怎么看？

Answer 1

它可能/将会破裂。执行示例:

• T1:if(!cont.isLocked()) 返回 true
• T2:set(someObject)
• T1: return cont.getObject(); 返回旧版本

更糟糕的是，由于您在 T2 和 T1 之间没有适当的先行发生关系，cont.getObject() 可能会返回对 T2 创建的新对象的引用，但指向到不一致/未完全构造的对象。

你有一个典型的先检查后行动的问题。

为什么不直接使用对象的 volatile 引用？

public class Controller {

    private volatile Object obj = new Object();

    public Object get(){ return obj; }
    public void set(Object o){ obj = o; }
}

那将是线程安全的。