0

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

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) and private final Integer mStringBLock = new Integer(0)in这样的成员变量，并分别在MyClassand 的 getter 和 setter 方法的同步块中使用它们吗？mStringAmStringB

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

4

3 回答 3

3

通常更简单的解决方案更容易实施。我还将使用 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;
    }
}
于 2012-08-20T20:20:10.470 回答
0

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

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

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

于 2012-08-20T19:59:34.293 回答
0

从哪里开始...

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

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

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

于 2012-08-20T20:00:43.273 回答