[java] 简单的ConcurrentHashMap

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);
        }
    }
}