HashTable不允许空key和空value，但是HashMap可以，HashMap允许存储一个空key和多个空value，空key是采用覆盖上个空key的方式。其实这样设计是合理的，因为项目中有时需要用的空key或者空value。
实现散列表同步的方式还有：Collections.synchronizedMap(Map<K,V> m)，但是其只是帮助开发者快速的将一个Map转换成可同步的，内部还是锁住整张表。包括Collections.synchronizedList(List<T> list)，Collections.synchronizedCollection(Collection<T> c)也是同样的道理，看实现就知道了：
private final Map<K,V> m; // Backing Map
final Object mutex; // Object on which to synchronize
SynchronizedMap(Map<K,V> m) {
this.m = Objects.requireNonNull(m);
mutex = this;
}
SynchronizedMap(Map<K,V> m, Object mutex) {
this.m = m;
this.mutex = mutex;
}
public int size() {
synchronized (mutex) {return m.size();}
}
public boolean isEmpty() {
synchronized (mutex) {return m.isEmpty();}
}
public boolean containsKey(Object key) {
synchronized (mutex) {return m.containsKey(key);}
}
public boolean containsValue(Object value) {
synchronized (mutex) {return m.containsValue(value);}
}
public V get(Object key) {
synchronized (mutex) {return m.get(key);}
}
public V put(K key, V value) {
synchronized (mutex) {return m.put(key, value);}
}
public V remove(Object key) {
synchronized (mutex) {return m.remove(key);}
}
public void putAll(Map<? extends K, ? extends V> map) {
synchronized (mutex) {m.putAll(map);}
}
public void clear() {
synchronized (mutex) {m.clear();}
}
而ConcurrentHashMap属于开创性的锁概念，分段锁，这和读写锁的意义是一样的。
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
public final String toString(){ return key + "=" + val; }
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
public final boolean equals(Object o) {
Object k, v, u; Map.Entry<?,?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
/**
* Virtualized support for map.get(); overridden in subclasses.
*/
Node<K,V> find(int h, Object k) {
Node<K,V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}
}
仍然是继承于Map.Entry<K,V>，是一个单链表结构。内部有哈希值，key，value和指向下一个结点的引用。hashCode()方法的实现是key的hashCode异或value的hashCode。equasl()方法的实现是key，value相同。并且提供结点查找find()方法，通过hash值和key进行查找，可以看出，ConcurrentHashMap解决哈希冲突的方法为链地址法。
而Segment则沦为序列化的工具：
/**
* 继承重入锁实现序列化接口
*/
static class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
// 加载因子，HashTable那章有介绍
final float loadFactor;
Segment(float lf) { this.loadFactor = lf; }
}
/**
* 通过对象流写入对象
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// For serialization compatibility
// Emulate segment calculation from previous version of this class
int sshift = 0;
int ssize = 1;
while (ssize < DEFAULT_CONCURRENCY_LEVEL) {
++sshift;
ssize <<= 1;
}
int segmentShift = 32 - sshift;
int segmentMask = ssize - 1;
@SuppressWarnings("unchecked")
Segment<K,V>[] segments = (Segment<K,V>[])
new Segment<?,?>[DEFAULT_CONCURRENCY_LEVEL];
for (int i = 0; i < segments.length; ++i)
segments = new Segment<K,V>(LOAD_FACTOR);
s.putFields().put("segments", segments);
s.putFields().put("segmentShift", segmentShift);
s.putFields().put("segmentMask", segmentMask);
s.writeFields();
Node<K,V>[] t;
if ((t = table) != null) {
Traverser<K,V> it = new Traverser<K,V>(t, t.length, 0, t.length);
for (Node<K,V> p; (p = it.advance()) != null; ) {
s.writeObject(p.key);
s.writeObject(p.val);
}
}
s.writeObject(null);
s.writeObject(null);
segments = null; // throw away
}
3.2 构造器
/**
* 最大容量，2的30次方
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认容量，必须是2的幂
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 最大数组容量
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 默认并发级别，JDK1.7就存在
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 通过初始容量，加载因子和并发级别创建一个新的空的ConcurrentHashMap
*/
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // Use at least as many bins
initialCapacity = concurrencyLevel; // as estimated threads
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
3.3 全局变量
ConcurrentHashMap中有两个变量：
今天也要加油鸭