WeakhashMap源码1
弱引用（WeakReference）的特性是：当gc线程发现某个对象只有弱引用指向它，那么就会将其销毁并回收内存。WeakReference也会被加入到引用队列queue中。
它的特殊之处在于 WeakHashMap 里的entry可能会被GC自动删除，即使程序员没有调用remove()或者clear()方法。
可能发生如下情况：
- 调用两次size()方法返回不同的值；
- 两次调用isEmpty()方法，第一次返回false，第二次返回true；
- 两次调用containsKey()方法，第一次返回true，第二次返回false，尽管两次使用的是同一个key；
- 两次调用get()方法，第一次返回一个value，第二次返回null，尽管两次使用的是同一个对象。
WeekHashMap 的这个特点特别适用于需要缓存的场景。
GC判断某个对象是否可被回收的依据是，是否有有效的引用指向该对象。
这里的“有效引用”并不包括弱引用。也就是说，虽然弱引用可以用来访问对象。
将一对key, value放入到 WeakHashMap 里并不能避免该key对应的内存区域被GC回收。
既然有 WeekHashMap，是否有 WeekHashSet 呢？答案是没有，不过Java Collections工具类给出了解决方案，
// 将WeakHashMap包装成一个Set
Set<Object> weakHashSet = Collections.newSetFromMap(new WeakHashMap<Object, Boolean>());
如果存放在WeakHashMap中的key都存在强引用，那么WeakHashMap就会退化为HashMap。
使用WeakHashMap可以忽略容量问题，提升缓存容量。只是当容量不够时，不会OOM，内部数据会被GC回收。命中率好像没有办法，容我掉一片头发换来深度思考后给出方案。
观察WeakHashMap源码可以发现，它是线程不安全的，所以在多线程场景该怎么办嘞？
WeakHashMap<String, String> weakHashMapintsmaze=new WeakHashMap<String, String>();
Map<String, String> intsmaze=Collections.synchronizedMap(weakHashMapintsmaze);
public class Test11 { private static final int _1MB = 1024 * 1024;// 设置大小为1MB public static void main(String[] args) throws InterruptedException { Object value = new Object(); WeakHashMap<Object, Object> map = new WeakHashMap<Object, Object>(); for (int i = 0; i < 100; i++) { byte[] bytes = new byte[_1MB]; // bytes和value构成Entry，bytes是弱引用，没有别人指向，就回去回收这个Entry。 map.put(bytes, value); } // 其实当我们在循环100次添加数据时，就已经开始回收弱引用了，因此我们会看到第一次打印的size是13，而不是100，一旦GC发生，那么弱引用就会被清除，导致WeakHashMap的大小为0。 // while (true) { System.gc();// 建议系统进行GC Thread.sleep(500); System.out.println(map.size());// 13 0 0 0 0 } } }
//WeakHashMap里面EntrySet的iterator()方法返回new EntryIterator()， //EntryIterator的next和hashNext方法是对WeakHashMap的table做的遍历。 //所以new EntrySet()，就返回WeakHashMap的table的所有元素。 public class eee { @SuppressWarnings("rawtypes") public static void main(String[] args) { Collection c = new eee().entrySet();//[6, 5, 4, 3, 2, 1] Iterator iter = c.iterator(); while (iter.hasNext()) { String entry = (String) iter.next(); System.out.println(entry); } } String[] table = new String[]{"1","2","3","4","5","6"}; String[] table1 = new String[]{"11","21","31","41","51","61"}; private transient Set<String> entrySet; public Set<String> entrySet() { Set<String> es = entrySet; return es != null ? es : (entrySet = new EntrySet());//是根据hasNext()和next()方法来确定集合元素的。 } private class EntrySet extends AbstractSet<String> { public Iterator<String> iterator() { return new EntryIterator(); //return null 那么new EntrySet()就没有元素了。 } @Override public int size() { return 0; } } private class EntryIterator<String> implements Iterator<String> { private int index; EntryIterator() { index = table.length; // index = table1.length; } public boolean hasNext() { if (index > 0) return true; else return false; } public String next() { return (String) table[--index]; // return (String) table1[--index]; } } }
当一个键对象被垃圾回收，那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间，可用来缓存那些非必须存在的数据。
get,put,size,isEmpty,containsKey,getEntry,resize,拷贝，putAll，remove，containsValue，containsNullValue，forEach都会清理脏数据。
keySet，values，entrySet不会清理脏数据。
WeakHashMap是不同步的。可以使用 Collections.synchronizedMap 方法来构造同步的 WeakHashMap。
WeakHashMap的Key是弱引用，Value不是。WeakHashMap不会自动释放失效的弱引用table中 Entry，仅当包含了expungeStaleEntries()的共有方法被调用的时候才会释放。
WeakHashMap没有实现Clone和Serializable接口，所以不具有克隆和序列化的特性。
WeakHashMap因为gc的时候会把没有强引用的key回收掉，所以注定了它里面的元素不会太多，因此也就不需要像HashMap那样元素多的时候转化为红黑树来处理了。
WeakHashmap将会移除一些死的（dread）的entry，避免持有过多死的弱引用。
ReferenceQuene能够轻易的追踪这些死掉的弱引用。可以讲ReferenceQuene传入WeakHashmap的构造方法（constructor）中，这样，一旦这个弱引用里面的对象成为垃圾，这个弱引用将加入ReferenceQuene中。
public static void main(String args[]) { WeakHashMap<String, String> map = new WeakHashMap<String, String>(); map.put(new String("1"), "1"); map.put("2", "2"); String s = new String("3"); map.put(s, "3"); while (map.size() > 0) { try { Thread.sleep(500); } catch (InterruptedException ignored) { } System.out.println("Map Size:" + map.size()); System.out.println(map.get("1")); System.out.println(map.get("2")); System.out.println(map.get("3")); System.gc(); } } }
运行结果（一直循环当中）：
Map Size:3 1 2 3
Map Size:2 null 2 3
根据String的特性，
元素“1”的key已经没有地方引用了，所以进行了回收。
元素“2”是被放在常量池中的，所以没有被回收。
元素“3”因为还有变量s的引用，所以也没有进行回收。
public class ss { public static void main(String[] args) { System.out.println(test());//cde } private static String test(){ String a = new String("a"); System.out.println(a);//a WeakReference<String> b = new WeakReference<String>(a); System.out.println(b.get());//a WeakHashMap<String, Integer> weakMap = new WeakHashMap<String, Integer>(); weakMap.put(b.get(), 1);//{a=1} a = null; System.out.println("GC前b.get()："+b.get());//a System.out.println("GC前weakMap："+weakMap);//{a=1} System.gc(); System.out.println("GC后"+b.get());//null,a=null; System.gc()后，b!=null,b中的a也被系统回收了， System.out.println("GC后"+weakMap);//{} String c = ""; try{ c = b.get().replace("a", "b");//b.get()为null，会抛出异常。 System.out.println("C:"+c); return c; }catch(Exception e){ //finally有renturn，从finally退出。finally没有renturn，从try退出。 //try 换成 catch 去理解就 OK 了 c = "c"; System.out.println("Exception"); return c; }finally{ c += "d"; return c + "e"; } } }
public class WeakHashMapTest { public static void main(String[] args) { WeakHashMap w= new WeakHashMap(); //三个key-value中的key 都是匿名对象，没有强引用指向该实际对象 w.put(new String("语文"),new String("优秀")); w.put(new String("数学"), new String("及格")); w.put(new String("英语"), new String("中等")); //增加一个字符串的强引用 w.put("java", new String("特别优秀")); System.out.println(w); //{java=特别优秀, 数学=及格, 英语=中等, 语文=优秀} //通知垃圾回收机制来进行回收 System.gc(); System.runFinalization(); //再次输出w System.out.println("第二次输出:"+w); //第二次输出:{java=特别优秀} } }
spliterator是java1.8引入的一种并行遍历的机制，Iterator提供也提供了对集合数据进行遍历的能力，但一个是顺序遍历，一个是并行遍历。
OfInt sInt = Arrays.spliterator(arr, 2, 5);//下标，包头不包尾。截取。
public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) { return Spliterators.spliterator(array, startInclusive, endExclusive, Spliterator.ORDERED | Spliterator.IMMUTABLE); } public static Spliterator.OfInt spliterator(int[] array, int fromIndex, int toIndex, int additionalCharacteristics) { checkFromToBounds(Objects.requireNonNull(array).length, fromIndex, toIndex); return new IntArraySpliterator(array, fromIndex, toIndex, additionalCharacteristics); } public IntArraySpliterator(int[] array, int origin, int fence, int additionalCharacteristics) { this.array = array; this.index = origin; this.fence = fence; this.characteristics = additionalCharacteristics | Spliterator.SIZED | Spliterator.SUBSIZED; } public boolean tryAdvance(IntConsumer action) {//对分割后的数组依次调用函数 if (action == null) throw new NullPointerException(); if (index >= 0 && index < fence) { action.accept(array[index++]); return true; } return false; } public OfInt trySplit() {//返回分割的数组 int lo = index, mid = (lo + fence) >>> 1; return (lo >= mid) ? null : new IntArraySpliterator(array, lo, index = mid, characteristics); } public void forEachRemaining(IntConsumer action) { int[] a; int i, hi; // 每个元素执行给定的操作 if (action == null) throw new NullPointerException(); if ((a = array).length >= (hi = fence) && (i = index) >= 0 && i < (index = hi)) { do { action.accept(a[i]); } while (++i < hi); } } public interface IntConsumer { void accept(int value); default IntConsumer andThen(IntConsumer after) { Objects.requireNonNull(after); return (int t) -> { accept(t); after.accept(t); }; } } andThen方法是由IntConsumer 对象调用的，返回值是IntConsumer 类型：一个函数，首先调用 调用andThen方法的对象的accept()方法，然后调用after的accept方法。 public boolean tryAdvance(IntConsumer action) { if (action == null) throw new NullPointerException(); if (index >= 0 && index < fence) { action.accept(array[index++]); return true; } return false; } public class ffff { public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; OfInt sInt = Arrays.spliterator(arr, 2, 5);// 返回3 4 5 IntConsumer consumer = new IntConsumer() { public void accept(int value) { System.out.println(value); } }; sInt.tryAdvance(consumer.andThen(new IntConsumer() {//先调用consumer的accept方法，在调用new IntConsumer()匿名内部类的accept方法， public void accept(int value) { System.out.println("i am after"); } })); sInt.tryAdvance(consumer.andThen(new IntConsumer() { public void accept(int value) { System.out.println("i am after"); } })); sInt.tryAdvance(consumer.andThen(new IntConsumer() { public void accept(int value) { System.out.println("i am after"); } })); sInt.tryAdvance(consumer.andThen(new IntConsumer() { public void accept(int value) { System.out.println("i am after"); } })); //3 i am after，4 i am after，5 i am after } public static void main3(String[] args) { int[] arr ={ 1, 2, 3, 4, 5, 6 }; IntConsumer consumer = new IntConsumer() {// IntConsumer的accept参数只能是int @Override public void accept(int value) { System.out.println(value); } }; OfInt sInt = Arrays.spliterator(arr);// sInt = {1,2,3,4,5,6} sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer);// 1,2,3,4,5,6 OfInt sInt1 = sInt.trySplit();// sInt1是sInt的前一半{1,2,3}，sInt是后一半{4,5,6} sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer);// 只有4 5 6 sInt1.tryAdvance(consumer); sInt1.tryAdvance(consumer); sInt1.tryAdvance(consumer); sInt1.tryAdvance(consumer); sInt1.tryAdvance(consumer); sInt1.tryAdvance(consumer);// 只有1 2 3 } public static void main2(String[] args) { int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; OfInt sInt = Arrays.spliterator(arr, 2, 5);// 下标，包头不包尾。截取。 IntConsumer consumer = new IntConsumer() { @Override public void accept(int value) { System.out.println(value); } }; sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); /* if (index >= 0 && index < fence) { consumer.accept(array[index++]); index和fence是sInt的属性 */ sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer);// 只输出3 4 5 ，遍历截取后的元素。 } public static void main1(String[] args) { int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; OfInt sInt = Arrays.spliterator(arr); IntConsumer consumer = new IntConsumer() { @Override public void accept(int value) { System.out.println(value); } }; sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer); sInt.tryAdvance(consumer);// 输出 1, 2, 3, 4, 5, 6, 7, 8, 9 } }
Spliterator就是为了并行遍历元素而设计的一个迭代器，jdk1.8中的集合框架中的数据结构都默认实现了spliterator，可以和iterator顺序遍历迭代器一起看。
Spliterator（splitable iterator可分割迭代器）接口是Java为了并行遍历数据源中的元素而设计的迭代器，这个可以类比最早Java提供的顺序遍历迭代器Iterator，但一个是顺序遍历，一个是并行遍历
第一个方法tryAdvance就是顺序处理每个元素，类似Iterator，如果还有元素要处理，则返回true，否则返回false
第二个方法trySplit，这就是为Spliterator专门设计的方法，区分与普通的Iterator，该方法会把当前元素划分一部分出去创建一个新的Spliterator作为返回，两个Spliterator变会并行执行，如果元素个数小到无法划分则返回null。二分法。
第三个方法estimateSize，该方法用于估算还剩下多少个元素需要遍历
第四个方法characteristics，其实就是表示该Spliterator有哪些特性，用于可以更好控制和优化Spliterator的使用，具体属性你可以随便百度到，这里就不再赘言
从最早Java提供顺序遍历迭代器Iterator时，那个时候还是单核时代，但现在多核时代下，顺序遍历已经不能满足需求了...如何把多个任务分配到不同核上并行执行，才是能最大发挥多核的能力，所以Spliterator应运而生啦
对于Spliterator接口的设计思想，应该要提到的是Java7的Fork/Join(分支/合并)框架，总得来说就是用递归的方式把并行的任务拆分成更小的子任务，然后把每个子任务的结果合并起来生成整体结果。带着这个理解来看看Spliterator接口提供的方法
