java - 具有不同类作为锁的同步块(synchronized block)

Question

我想知道我对synchronized(x.class){..}的理解是否是正确的。

假设:

我在一个类中有两个变量，如果需要，它们将被初始化。但只有一次。

我想阻止从不同线程对每个变量的多次访问。

我只想明智地阻止变量，而不是完整的 SingletonExample 实例。

示例:

public class SingletonExample{

    private volatile SingletonA var;
    private volatile SingletonB tar;

    public void initVarOnDemand1() {
        if (var == null) {
            synchronized (SingletonA.class) {
                if (var == null) {
                    var = SingletonA.getInstance(1);
                }
            }
        }
    }

    public void initVarOnDemand2() {
        if (var == null) {
            synchronized (SingletonA.class) {
                if (var == null) {
                    var = SingletonA.getInstance(2);
                }
            }
        }
    }

    public void initTarOnDemand1() {
        if (tar == null) {
            synchronized (SingletonB.class) {
                if (tar == null) {
                    tar = new SingletonB.getInstance(1);
                }
            }
        }
    }

    public void initTarOnDemand2() {
        if (tar == null) {
            synchronized (SingletonB.class) {
                if (tar == null) {
                    tar = SingletonB.getInstance(2);
                }
            }
        }
    }
}

我的最终目标是，没有两个线程可以同时更改变量 var并且没有两个线程可以同时更改变量 tar .

但我不想阻止访问不同变量的两个线程。

因此，我使用与每个类的 block 同步作为锁定对象。

这是我想要的正确方法吗？ (我希望我解释得足够好 - 对不起我的英语不好)。

Answer 1

更好的方法是使用 AtomicReference.compareAndSet :

private final AtomicReference<Integer> var = new AtomicReference<>();

public void foo() {
  var.compareAndSet(null, 1);
}

public void bar() {
  var.compareAndSet(null, -1);
}

这仅设置 var 的值如果它的当前值等于第一个参数(在本例中为 null)。