[7]-集合类

HashMap(容量，负载因子)：非线程安全

• 数组+链表实现

• 当Entry节点数量超过容量负载因子，进行扩容*2，进行resize()

• 对key的hashCode()进行indexfor获得位置,因为取余效率低

• 如果该位置没有碰撞、直接存到bucket中；如果发生碰撞，遍历链表有没有相等的key，
  
  • 有就替换该Entry的value；没有就addEntry()，是否扩容，创建一个Entry作为链表头
• jdk8后来做的改进是、如果碰撞导致链表过长，长度超过8，把链表转换成红黑树
  
  
• resize()就是线程不安全的源头：多线程同时resize()可能会产生Entry的环

Entry put(K key,v value){    if (key == null) { return putForNullKey(value); }     int i = indexFor(hash(key), table.length);      for (Entry< K,V> e = table[i]; e != null; e = e.next) {          if (e.hash == hash && (eKey== key || key.equals(eKey))) {              V oldValue = e.value;              e.value = value;              e.recordAccess(this);              return oldValue;          }      }     modCount++;      addEntry(hash, key, value, i);      return null;   }void addEntry(int hash, K key, V value, int bucketIndex) {    if ((size >= threshold) && (null != table[bucketIndex])) {        resize(2 * table.length);        hash = (null != key) ? hash(key) : 0;        bucketIndex = indexFor(hash, table.length);    }    createEntry(hash, key, value, bucketIndex);}void createEntry(int hash, K key, V value, int bucketIndex) {    Entry<K,V> e = table[bucketIndex];    table[bucketIndex] = new Entry<>(hash, key, value, e);    size++;}void transfer(Entry[] newTable){    Entry[] src = table;    int newCapacity = newTable.length;    for (int j = 0; j < src.length; j++) {        Entry< K,V> e = src[j];        if (e != null) {            src[j] = null;            do {                Entry<K,V> next = e.next;                int i = indexFor(e.hash, newCapacity);                e.next = newTable[i];                newTable[i] = e;                e = next;            }             while (e != null);        }    }}

---

Hashtable：所有函数都是同步有锁

• 效率低下、所有访问HashTable的线程都必须竞争同一把锁
• 继承`Dictionary类，实现了Map接口
• 他的key、value都不能是null

---

ConcurrentHashMap：锁分段、元素HashMap

• 由Segment[]数组构成、每一个Segment与HashMap类型相似
• Entry的变量final类型（除了value：volatile）
• 除了容量、负载因子，还加了一个参数 concurrencyLevel

• egment[]数组的长度是大于或等于concurrencyLevel的最小的2的N次方值

• 同步有锁、锁分段技术、

  • 首先将数据分成一段一段的存储，然后给每一段数据配一把锁，
  • 当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问

• 定位Segment：HashMap中的hash()一样，为了减少哈希冲突

• Segment< K,V> segmentFor(hash)右移28位、让高四位参与到运算中)&(segmentMask掩码默认是8)
• get()是无锁的：判断entry的value是否为null，是就加锁

public V get(Object key) {    int hash = hash(key);    return segmentFor(hash).get(key, hash); } V get(Object key, int hash) {    //volatile修饰count    if (count != 0){         HashEntry<K,V> e = getFirst(hash);         while (e != null) {            if (e.hash == hash && key.equals(e.key)) {                V v = e.value;                if (v != null) {                    return v;                }                return readValueUnderLock(e);            }            e = e.next;        }    }    return null;}

• put()、remove()、ReentrantLock加锁
• 修改：突然另一个进程修改了我们想get()的Entry的value：value是volatile的，没关系
• 增加：突然另一个线程在链表头put()了一个我们想get()的Entry
  
  • if (v != null) 的判断，对new出来的对象进行状态检测，不为null，返回
  • 还为null的话，readValueUnderLock()，锁定之后返回一个值(value不允许为null)
• 删除：突然另一个进程删除了我们想get()的Entry
  
  • 因为next变量是final的，所以只能在table[index]重链接一条单链表，e1-e2-e3-e4，删e3
  • 变成e2-e1-e4，如果我们已顺着原链表到了e1了，继续顺着原来的走，仍会返回e3
• ConcurrentHashMap的迭代器不是快速失败

---

List

• ArrayList：动态扩容1.5倍（下标访问-尾部插入高效-其他位置System.arraycopy()）
• LinkedList：双向链表（两头插入删除高效-其他位置）
• CopyOnWriteArrayList（java.util.concurrent）：只有写锁、没有读锁。适合读多写少的场景
  
  • 在修改时先复制一个快照Arrays.copyof()，每次写都在新数组写，指针指向新数组

---

Map

• LinkedHashMap：双向链表：按Entry插入顺序排序：LRU（accessOrder=true）
• TreeMap：红黑树实现、iterator()有序遍历key、Comparable或Comparator

---

Queue：两端出入的List

• PriorityQueue：二叉堆：iterator()不保证有序遍历
• LinkedList：双向链表：唯一允许放入null的Queue
• ArrayDeque：循环数组：push尾增，pop头增，尾追上头无空间
  
  
• ConcurrentLinkedQueue：线程安全：单向链表：CAS无锁
• PriorityBlockingQueue：线程安全：二叉堆：读写一把锁：阻塞接口，无阻塞特性
  
  
• ArrayBlockingQueue：线程安全阻塞：循环数组：读写一把锁
• LinkedBlockingQueue：线程安全阻塞：链表：两把锁

---

public class LruLinkedHashMap<K,V> extends LinkedHashMap<K,V>{    public int cap;    LruLinkedHashMap(int cap){        //LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)        super(cap,0.75f,true);        this.cap=cap;    }    public boolean removeEldestEntry(Map.Entry<K, V> eldest){        return size()>cap;    }}

---