Java弱引用集合WeakHashMap总结

2023-09-07 11:20:57 作者：feiyingHiei

这篇文章主要介绍了Java弱引用集合WeakHashMap总结,WeakHashMap利用WeakReference的弱引用特性让用户在使用的过程中不会因为没有释放Map中的资源而导致内存泄露,WeakHashMap实现了Map接口,使用方式和其他的Map相同,需要的朋友可以参考下

前言

WeakHashMap利用WeakReference的弱引用特性让用户在使用的过程中不会因为没有释放Map中的资源而导致内存泄露。

WeakHashMap实现了Map接口，使用方式和其他的Map相同，需要注意的是get方法和size方法的使用。在介绍WeakHashMap之前需要先介绍一下Reference的概念。

1、Reference的实现

public abstract class Reference<T> {
    private T referent;   //对应的引用对象
    volatile ReferenceQueue<? super T> queue; //引用队列，初始化的时候从外部传入
    Reference next;  // 当引用对象可达性发生变化的时候，next会指向当前引用
    transient private Reference<T> discovered;  /* used by VM */
    static private class Lock { } 
    private static Lock lock = new Lock(); //用来同步锁操作
}

Reference类有四个直接子类，PhantomReference、FinalReference、SoftReference、WeakReference。

其中SoftReference比WeakReference约束要强一些，当内存不够用的时候JVM才会将对应引用的对象删除掉，而WeakReference在对象引用不可达的时候就会被JVM清理掉，PhantomReference（虚引用）和约束更弱，get方法永远都返回null，无法像前两者一样可以通过get()方法获取一个强引用，PhantomReference只能用来监控对象的GC状况。

无论哪种Reference，都有一个重要的对象来跟踪对象的gc动作，这个就是ReferenceQueue。

2、ReferenceQueue的实现

public class ReferenceQueue {
    static private class Lock { }; //锁对象，用来同步队列操作
    private Lock lock = new Lock(); 
    private volatile Reference<? extends T> head = null; //头结点
    private long queueLength = 0; //队列长度
}

入队操作

boolean enqueue(Reference<? extends T> r) { /* Called only by Reference class */
   synchronized (lock) {
        ReferenceQueue<?> queue = r.queue; //获取reference之前的队列，如果没有绑定队列，那就不需要入队
        if ((queue == NULL) || (queue == ENQUEUED)) {
            return false;
        }
        assert queue == this;
        r.queue = ENQUEUED;
        r.next = (head == null) ? r : head; //把r从链表的头部插入
        head = r; //头结点指向r
        queueLength++; //队列长度+1
        if (r instanceof FinalReference) {
            sun.misc.VM.addFinalRefCount(1);
        }
        lock.notifyAll(); //唤醒删除线程删除头结点
        return true;
    }
}

出队列的操作相似，每个reference就是链表中的一个节点，next指向下一个reference节点。

删除操作

public Reference<? extends T> remove(long timeout)
    throws IllegalArgumentException, InterruptedException
{
    if (timeout < 0) {
        throw new IllegalArgumentException("Negative timeout value");
    }
    synchronized (lock) {
        Reference<? extends T> r = reallyPoll(); //尝试获取队列的头结点
        if (r != null) return r; //获取成功，返回
        long start = (timeout == 0) ? 0 : System.nanoTime(); //如果超时时间不为0，就记录一下当前的开始时间
        for (;;) {
            lock.wait(timeout);
            r = reallyPoll();
            if (r != null) return r;
            if (timeout != 0) {
                long end = System.nanoTime();
                timeout -= (end - start) / 1000_000; //计算一下等待的时间
                if (timeout <= 0) return null; //确认等待是否是超时，如果是就返回，否则就认为是有入队请求唤醒当前线程，但是当前线程尝试删除头结点失败了（被其他线程删除了），那么继续尝试删除头结点，再次执行循环中的内容直到超时
                start = end;
            }
        }
    }
}

ReferenceQueue是线程安全的，出队入队操作都由lock对象来保证线程安全，当用户线程和jvm线程同时访问ReferenceQueue的时候不会出现并发问题。

WeakHashMap

WeakHashMap内部同样是通过一个数组来实现存储，解决冲突的方式也是使用拉链法，weakHashMap中重新定义了Entry类来存储kv键值对，Entry的实现也是实现WeakHashMap特性的关键。

1、Entry的定义

WeakHashMap重新定义了一个entry,这个entry继承了WeakReference类并且实现了Entry接口，使用该Entry存储键值对不会产生强引用

jvm在垃圾回收的时候不会认为该引用是强引用，会正常的回收对象

Entry的定义如下

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
  V value;          //存储的value    
  final int hash;   //hash值
  Entry<K,V> next;  //拉链法解决冲突，形成单链表
  Entry(Object key, V value,ReferenceQueue<Object> queue, int hash, Entry<K,V> next) {
  super(key, queue);   //这里的引用对象是key，跟踪的是key对象的垃圾回收
  this.value = value;
  this.hash  = hash;
  this.next  = next;
  }
  ...
}

Entry的构造器需要传入ReferenceQueue，这个queue就可以用来监控全局的Entry被清理的情况。

2、清理操作

当对象被垃圾回收的时候，当前Map需要删除掉对应的Entry，因为Entry此时指向的对象已经被回收，所以需要找到被JVM回收的对象对应的Entry并且将Entry对象从Map中移除掉，实现方式是expungeStaleEntries方法

private void expungeStaleEntries() {
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>) x;
            int i = indexFor(e.hash, table.length); //从队列中拿到entry，根据entry获取entry链表在table中的索引
            Entry<K,V> prev = table[i]; //找到entry链表的头结点
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next; //找到对应节点
                    else
                        prev.next = next;
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

该方法在map中的getTable()、size()和resize()方法中被调用，每次put或是get的时候都会先执行getTable()方法，因此每次读写数据的时候都会清理掉无用的entry，所以用户不会获取到被垃圾回收的清理entry

因此，每次用户调用get方法或是size方法的时候，都会触发清理操作，所以每次返回的结果可能都不相同，因为内部的entry持有的对象已经被jvm回收。

线程安全问题

WeakHashMap作为容器本事不是线程安全的，但是在使用过程中，ReferenceQueue可能会被当前业务线程和JVM线程并发访问，ReferenceQueue是线程安全的。

到此这篇关于Java弱引用集合WeakHashMap总结的文章就介绍到这了,更多相关WeakHashMap总结内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！