Codenameone 代码名为1的ConcurrentHashMap

我需要从不同的线程（EDT、计时器，可能还有网络线程）使用相同的

HashMap

。由于Codename One的API中没有

ConcurrentHashMap

实现，因此我试图绕过此问题：

/**
 * ConcurrentHashMap emulation for Codename One.
 */
public class ConcurrentHashMap<K, V> {

    private static final EasyThread thread = EasyThread.start("concurrentHashMap_Thread");
    private final Map<K, V> map = new HashMap<>();

    public V put(K key, V value) {
        return thread.run(() -> map.put(key, value));
    }

    public V get(K key) {
        return thread.run(() -> map.get(key));
    }

    public V remove(K key) {
        return thread.run(() -> map.remove(key));
    }

}

/**
*代码名为1的ConcurrentHashMap仿真。
*/
公共类ConcurrentHashMap{
私有静态最终EasyThread线程=EasyThread.start（“concurrentHashMap_线程”）；
私有最终映射=新HashMap（）；
公共V输入（K键，V值）{
返回thread.run（（）->map.put（key，value））；
}
公共V get（K键）{
返回thread.run（（）->map.get（key））；
}
公共V移除（K键）{
返回thread.run（（）->map.remove（key））；
}
}

我有两个问题：

当从两个或多个线程访问

Map

时，在Codename One中是否需要上面这样的代码？直接使用

HashMap

是否更好

你觉得那个代码怎么样？我试图让它尽可能简单，但我不确定它的正确性

---

那个代码非常正确。在创建多个锁以将新对象添加到另一个线程时，这也是非常低效的。所以你实际上是把坦克带到了一个更简单的问题上

TL；DR是这样的：

map = Collections.synchronizedMap(map);

您的代码可以这样编写，而且效率更高：

public class ConcurrentHashMap<K, V> {
    private static final EasyThread thread = EasyThread.start("concurrentHashMap_Thread");
    private final Map<K, V> map = new HashMap<>();

    public synchronized V put(K key, V value) {
        return map.put(key, value);
    }

    public synchronized V get(K key) {
        return map.get(key);
    }

    public synchronized V remove(K key) {
        return map.remove(key);
    }
}

公共类ConcurrentHashMap{
私有静态最终EasyThread线程=EasyThread.start（“concurrentHashMap_线程”）；
私有最终映射=新HashMap（）；
公共同步V输入（K键，V值）{
返回map.put（键、值）；
}
公共同步V get（K键）{
返回map.get（key）；
}
公共同步V删除（K键）{
返回地图。删除（键）；
}
}

但是您显然不需要它，因为我们有

synchronizedMap

方法

那么为什么我们没有

ConcurrentHashMap

因为我们不在大型服务器上运行。见本文：

---

TL；这篇文章的主要观点是，当您拥有大量线程和大量服务器内核时，

ConcurrentHashMap

是有意义的。它试图在最大规模的限制同步上多走一英里。在移动领域，这是一个巨大的滥杀滥伤。

感谢您详细而清晰的解释：）