类的 getter/setter 方法和单例模式中的 Java 细粒度同步

Question

我正在尝试使用synchronization java 指令在类中实现细粒度同步，即同步尽可能少的代码。我将内联注释代码，以解释我的工作和在代码之后我会问你如何改进代码：

public class MyClass {
    private static volatile MyClass singletonInstance = null;

    private HashMap<String, Integer> mHashMap = null;
    private String mStringA = null;
    private String mStringB = null;


     // Use double check technique to use synchronization only 
     // at the first getInstance() invocation
    public static MyClass getInstance() {
        if (singletonInstance == null) {
            synchronized (MyClass.class) {
                if (singletonInstance == null)
                    singletonInstance = new MyClass();
                    // Initialize class member variables
                    singletonInstance.mHashMap = new HashMap<String,Integer>();
                    singletonInstance.mStringA = new String();
                    singletonInstance.mStringB = new String();
            }

        }
        return singletonInstance;
    }

    // The following two methods manipulate the HashMap mHashMap
    // in a secure way since they lock the mHashMap instance which
    // is always the same and is unique
    public Integer getIntegerFromHashmap(String key) {
        synchronized (mHashMap) {
            return mHashMap.get(key);
        }
    }

    public void setIntegerIntoHashmap(String key, Integer value) {
        synchronized (mHashMap) {
            mHashMap.put(key, value);
        }
    }

    // With the two String members mStringA and mStringB the problem is 
    // that the instance of String pointed by the member is varied by the 
    // setter methods, so we can not lock in a fine grained way and we
    // must lock on the singletonInstance.
    public String getStringA() {
        synchronized (singletonInstance) {
            return mStringA;
        }
    }

    public String getStringB() {
        synchronized (singletonInstance) {
            return mStringB;
        }
    }

    public void setStringA(String newString) {
        synchronized (singletonInstance) {
            mStringA = newString;
        }
    }

    public void setStringB(String newString) {
        synchronized (singletonInstance) {
            mStringB = newString;
        }
    }
}

我不喜欢两个String 成员变量的getter 和setter 方法是锁定singletonInstance 可以使试图访问mStringB 的线程等到正在操作mStringA 的线程释放它的锁。在这种情况下你会怎么做？您是否会在MyClass 中创建两个成员变量，如private final Integer mStringALock = new Integer(0) 和private final Integer mStringBLock = new Integer(0)，并分别在mStringA 和mStringB 的getter 和setter 方法的同步块中使用它们？

如果您对如何改进上述代码以及针对String 成员变量的细粒度同步提出的变体有一些想法，欢迎您:)

Answer 1

通常更简单的解决方案更易于实施。我还会使用 2004 年添加的并发库。

这不需要显式锁定，并且每个容器都是线程安全的。

您可以使用 AtomicReference，但在这种情况下，它不会为您提供任何 volatile 尚未提供的东西。 （正如 kdgregory 指出的那样）您可能会在更复杂的情况下使用 AtomicReference。

public enum MyClass {
    INSTANCE;

    private final Map<String, Integer> mHashMap = new ConcurrentHashMap<String, Integer>();
    private volatile String mStringA = null;
    private volatile String mStringB = null;


    // The following two methods manipulate the HashMap mHashMap
    // in a secure way
    public Integer getIntegerFromHashmap(String key) {
        return mHashMap.get(key);
    }

    public void setIntegerIntoHashmap(String key, Integer value) {
        mHashMap.put(key, value);
    }

    public String getStringA() {
        return mStringA;
    }

    public String getStringB() {
        return mStringB;
    }

    public void setStringA(String newString) {
        mStringA = newString;
    }

    public void setStringB(String newString) {
        mStringB = newString;
    }
}

Answer 2

是的，如果您希望线程能够同时调用这两个方法，则需要两个单独的锁。我会说没有什么可以改进的。

但是，我注意到您的 getInstance() 方法试图最小化要同步的块的大小，但您实际上并没有做到这一点，即您也检查了同步块内的 singletonInstance == null。所以，我认为用synchronized 来限定整个方法会更好。

它缩短了该方法的代码，也使它更自然一点。

Answer 3

从哪里开始...

好的，双重检查锁定：它已经坏了（仍然），不要使用它。如果您觉得必须使用单例（实际上，它们通常是个坏主意，请改用依赖注入），然后同步 getter 方法，并快速返回。在这种情况下，有争议的同步的可能性非常低，除非您拥有真正大量的内核（如数千个）并且不断调用 getter 方法。

将HashMap 替换为ConcurrentHashMap。 Doug Lea 在并发编码方面比你我都好。

将字符串变量标记为 volatile 并且不同步它们。