public class WearReferenceTest {
    public static void main(String[] args) {
        ReferenceQueue<String> queue = new ReferenceQueue<>();
        // 创建弱引用, 指向一个String对象
        WeakReference<String> wr = new WeakReference(new String("weakReference"), queue);
		// 获取弱引用中的对象
        System.out.println(wr.get()); // weakReference
		// 手动FullGC
        System.gc();
        // 再次查看弱引用中的对象
        System.out.println(wr.get()); // null
        System.out.println(queue.poll() == wr); // true
    }
}

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        // k是ThreadLocal对象
        super(k);
        value = v; // 在ThreadLocal中存储的值.
    }
}

private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

// ThreadLocal中
// 这个在上一篇讲过
public T get() {
    // 拿到当前线程
    Thread t = Thread.currentThread();
    // 拿到线程对应的哈希表
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 拿到对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 懒加载, 哈希表没有初始化或者没有找到对应的值, 设置初始值
    return setInitialValue();
}
// ThreadLocal.ThreadLocalMap
// 拿到key对应的Entry
private Entry getEntry(ThreadLocal<?> key) {
    // 取哈希值
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 如果直接命中, 就返回结果
    if (e != null && e.get() == key)
        return e;
    // 否则, 说明出现了哈希冲突, 继续查找
    else
        return getEntryAfterMiss(key, i, e);
}
// ThreadLocal.ThreadLocalMap
// 线性查找法
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
	// 如果e为空, 说明不存在这个元素
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 如果找到了
        if (k == key)
            return e;
        // 如果某个key为null, 因为是弱引用, 说明当前key已经被垃圾回收. 对后面的元素进行rehash
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    // 没有找到
    return null;
}

// java.lang.ThreadLocal
private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    // 线性探测
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        // 找到元素对应的Entry
        if (e.get() == key) {
            // 把key设置为null
            e.clear();
            // 对哈希表进行rehash
            expungeStaleEntry(i);
            return;
        }
    }
}

// staleSlot是我们遇到的第一个key==null的Entry的索引
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
	// 把staleSlot对应的索引清除掉
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

	// rehash
    Entry e;
    int i;
    // 向后搜索, tab是一个循环队列, nextIndex就是(i + 1) % len
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        // 如果遇到被回收的Entry, 把这个Entry清空. 
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

private boolean cleanSomeSlots(int i, int n) {
    // 标志有没有进行清理
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        // 如果找到了垃圾
        if (e != null && e.get() == null) {
            // 将搜索距离重置为len
            n = len;
            // 进行清理
            removed = true;
            i = expungeStaleEntry(i);
        }
        // 启发式搜索
        // 如果log(n)个格子没有找到垃圾, 就不继续搜索了
    } while ( (n >>>= 1) != 0);
    return removed;
}

private static final ThreadLocal<Random> RAND