Java中的四种引用

1

Object obj = new Object();

1


5

Object obj1 = new Object();
WeakReference<Object> weakObj1 = new WeakReference<Object>(obj1);
WeakReference<Object> weakObj2 = new WeakReference<Object>(new Object());
//主动回收
System.gc();

System.out.println(weakObj1.get()); // 非null
System.out.println(weakObj2.get()); // null

1


5


9


13


17


21


25


29


33


37


41

import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

public final class ConcurrentCache<K,V> {
    //LRU所允许的最大缓存量
    private final int size;
    private final Map<K,V> eden;
    private final Map<K,V> longterm;
    
    public ConcurrentCache(int size) {
        this.size = size;
        //eden是主要缓存
        this.eden = new ConcurrentHashMap<>(size);
        //longterm是实现LRU算法的关键点.
        this.longterm = new WeakHashMap<>(size);
    }
    
    //get是先从eden中取出缓存,当不存在时则去longterm中获取缓存,并且此时获取到的缓存说明还在使用,因此会put到eden中(LRU算法)
    public V get(K k) {
        V v = this.eden.get(k);
        if (v == null) {
            synchronized (longterm) {
                v = this.longterm.get(k);
            }
            if (v != null) {
                this.eden.put(k, v);
            }
        }
        return v;
    }
    //put操作当size大于LRU最大容量时,则把缓存都放入到longterm,当this.eden.clear()后使其成为弱引用,那么LRU的实现则在get方法中体现了出来.
    public void put(K k, V v) {
        if (this.eden.size() >= size) {
            synchronized (longterm) {
                this.longterm.putAll(this.eden);
            }
            this.eden.clear();
        }
        this.eden.put(k, v);
    }
}

1


5

Tracker(String path, FileDeleteStrategy deleteStrategy, Object marker, ReferenceQueue<? super Object> queue) {
    //marker是具体的虚引用对象
    super(marker, queue);
    this.path = path;
    this.deleteStrategy = deleteStrategy == null ? FileDeleteStrategy.NORMAL : deleteStrategy;
}

1


5


9


13


17

@Override
        public void run() {
            // thread exits when exitWhenFinished is true and there are no more tracked objects
            while (exitWhenFinished == false || trackers.size() > 0) {
                try {
                    // Wait for a tracker to remove.
                    Tracker tracker = (Tracker) q.remove(); // cannot return null
                    trackers.remove(tracker);
                    if (!tracker.delete()) {
                        deleteFailures.add(tracker.getPath());
                    }
                    tracker.clear();
                } catch (InterruptedException e) {
                    continue;
                }
            }
        }

1


5

Entry(Object key, V value,
         ReferenceQueue<Object> queue,
         int hash, Entry<K,V> next) {
       super(key, queue); // 把Key传入WeakReference的构造函数中
       this.value = value;
       this.hash  = hash;
       this.next  = next;
   }

1


5


9


13


17


21


25

private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) { // 每一次回收都会加锁
                @SuppressWarnings("unchecked")
                    Entry<K,V> e = (Entry<K,V>) x; //被回收的key
                int i = indexFor(e.hash, table.length); // 找到对应的hash槽

                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                while (p != null) { // 遍历hash槽对应的链，找到该entry之后修改链表
                    Entry<K,V> next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

1


5


9


13

public abstract class Reference<T> {

    private T referent;         /* Treated specially by GC */

    // 引用所关联的引用队列，构造函数传入
    volatile ReferenceQueue<? super T> queue;

    // 单链表
    @SuppressWarnings("rawtypes")
    volatile Reference next;

    transient private Reference<T> discovered;  /* used by VM */

    // 被回收的对象列表，注意是static，全局共享
    private static Reference<Object> pending = null;
}