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释放锁定。在这种情况下你会做什么？您是否会在private final Integer mStringALock = new Integer(0)中创建两个成员变量，例如private final Integer mStringBLock = new Integer(0)和MyClass，并在mStringA和mStringB的getter和setter方法的synchronized块中使用它们，分别？

如果您对如何改进上述代码以及String成员变量的细粒度同步的建议变体有一些想法，欢迎您：）

Answer 1

通常更简单的解决方案更容易实现。我还将在2004年使用并发库添加。

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

你可以使用AtomicReference，但在这种情况下，它不会给你任何挥发性的东西，而不是已经给你。（正如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，不要同步它们。

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

3 个答案: