[java] 简单的ConcurrentHashMap

  • Z时代
  • 2024-01-10
  • 分类：综合

java

ConcurrentMap和Guava的LocalCache实现原理相近，底层的存储方式使用的时table方式来存储。这里使用最简单且最暴力的方式，在每次访问的时候均加锁。

ConcurrentHashMap接口:

public interface ConcurrentHashMap<K, V> {
    public V get(K k);
    public void put(K key, V value);
    public void putAll(Iterable<MapEntry<K, V>> kIterator);
    public V remove(K k);
}

　　MapEntry:

public class MapEntry<K, V> {
    private K key;
    private V value;
    public K getKey() {
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

　　SimpleConcurrentHashMap接口:

import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import java.util.HashMap;
import java.util.Iterator;
public class SimpleConcurrentHashMap<K, V> implements ConcurrentHashMap<K, V> {
    private final HashMap<K, V> cache = Maps.newHashMap();
    public SimpleConcurrentHashMap() {
    }
    @Override
    public V get(K k) {
        Preconditions.checkNotNull(k);
        synchronized (cache) {
            return cache.get(k);
        }
    }
    @Override
    public void put(K key, V value) {
        Preconditions.checkNotNull(key);
        Preconditions.checkNotNull(value);
        synchronized (cache) {
            cache.put(key, value);
        }
    }
    @Override
    public void putAll(Iterable<MapEntry<K, V>> entryIterable) {
        Preconditions.checkNotNull(entryIterable);
        Iterator<MapEntry<K, V>> iterator = entryIterable.iterator();
        while (iterator.hasNext()) {
            MapEntry<K, V> next = iterator.next();
            this.put(next.getKey(), next.getValue());
        }
    }
    @Override
    public V remove(K k) {
        Preconditions.checkNotNull(k);
        synchronized (cache) {
            return cache.remove(k);
        }
    }
}

　　

以上是 [java] 简单的ConcurrentHashMap 的全部内容， 来源链接： utcz.com/z/389648.html

回到顶部