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

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 方法的同步块(synchronized block)中使用它们？

如果您对如何改进上述代码以及 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;
    }
}