Java中的引用与ThreadLocal

Java中的引用–强软弱虚

强引用

Object object = new Object(),这个object就是一个强引用。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError异常,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。

软引用(SoftReference)

如果一个对象只具有软引用,那就类似于可有可物的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

public class TestSoftReference {
    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        // m强引用指向softReference,softReference软指向byte[]
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024 * 1024 * 10],queue);
        // 打印结果:[[email protected]
        System.out.println(m.get());
        System.gc();
        Thread.sleep(1000);
        // 打印结果:[[email protected] 表示没有被垃圾回收
        System.out.println(m.get());
        // 给出一个强引用
        byte[] bytes = new byte[1024 * 1024 * 15];
        // 不规定最大堆内存大小时,打印结果:[[email protected]
        // 指定最大堆内存-Xmx20M时,打印输出null
        System.out.println(m.get());
        //打印结果:[email protected]
        System.out.println(queue.poll());
    }
}

不指定参数,输出结果

[[email protected]
[[email protected]
[[email protected]
null

指定参数-Xmx20M,输出结果

[[email protected]
[[email protected]
null
[email protected]

弱引用(WeakReference)

如果一个对象只具有弱引用,那就类似于可有可物的生活用品。弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程, 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

public class TestWeakReference {
    public static void main(String[] args) {
        WeakReference<byte[]> m = new WeakReference<>(new byte[1024*1024*10]);
        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());
    }
}

有垃圾回收直接回收,打印结果:

[[email protected]
null

虚引用(PhantomReference)

顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。 主要用在管理对外内存

ThreadLocal

ThreadLocal提供线程局部变量。这些变量与普通变量不同,因为每个线程都有其自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态变量,并将它与线程的状态绑定(例如,用户ID或事务ID)。

简单案例:

public class TestThreadLocal {
    private static final AtomicInteger nextId = new AtomicInteger(0);

    private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(nextId::getAndIncrement);

    public static int get() {
        return threadId.get();
    }

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(TestThreadLocal.get());   // 0
            try {
                Thread.sleep(1000);
                System.out.println(TestThreadLocal.get());   // 0
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(()->{System.out.println(TestThreadLocal.get());}).start();   // 1
    }
}

这里通过ThreadLocal对象threadId为每一个调用TestThreadLocal.get()方法的线程赋予一个线程Id,第4行通过ThreadLocal.withInitial(nextId::getAndIncrement)得到ThreadLocal的子类SuppliedThreadLocal对象,SuppliedThreadLocal对象复写了initialValue方法。

        @Override
        protected T initialValue() {
            return supplier.get();
        }

具体细节下面再谈。先看看main方法,其中启动了两个线程,可以看到每个线程通过调用TestThreadLocal.get()得到独有的Id。接下来分析ThreadLocal的主要方法。

set方法

源代码:

    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 得到线程的threadLocals属性,是ThreadLocalMap对象,其中k为这个ThreadLocal对象,v为value
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

从中可以看到ThreadLocalMap对象是实现功能的关键,整体思路和HashMap相似,具体代码就不细看了,有兴趣可以自己点进去看,接下来只讲述其中的关键点。ThreadLocalMap维护了一个Entry数组,对ThreadLocal对象的HashCode进行处理后作为index将Entry对象添加到数组中。接下来就是重中之重,Entry类:

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

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

可以看到Entry类继承了 WeakReference,他的弱引用指向了ThreadLocal对象,并且拥有属性value。看下来可能有点晕了,给出一个图方便理解

Java中的引用与ThreadLocal插图

可以理解为每一个Thread都有一个ThreadLocalMap属性,其中key为弱引用指向ThreadLocal,value为强引用指向传入的对象。

为什么要用弱引用作为key?

如果key为强引用,当我们现在将ThreadLocal的引用指向为null,但是每个线程中有自己独立ThreadLocalMap,还会一直持有该对象,所以ThreadLocal对象不会被回收,会发生内存泄漏问题。如果key为弱引用,当我们现在将ThreadLocal的引用指向为null时,线程中独立的ThreadLocalMap中的ThreadLocal对象会被回收。

还是有内存泄漏?

但是会发现就算是key被回收了,value也仍然被Entry中的value强引用指着不会被回收,依然会发生内存泄漏,所以在不用value的时候应该主动调用ThreadLocal对象的remove方法来移除。

remove方法

源代码:

        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)]) {
                if (e.get() == key) {
                    e.clear();   // 清理弱引用
                    expungeStaleEntry(i);
                    return;
                }
            }
        }

expungeStaleEntry(i);Entry数组的第i个entry对象的value置为null,然后将这个enrty对象置为null,最后进行rehash。

get方法

源代码:

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

在get方法中,通过getMap()获得当前Thread对象的threadLocals属性。在没有调用set方法之前,threadLocals属性为null,所以会调用setInitialValue()

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

可以看到,直接调用initialValue()方法得到value,然后设置并返回value,这就是前面为什么重写initialValue()方法。通过重写initialValue()方法,给顶一个初始值,这样在没有调用set方法之前调用get方法就会从initialValue()中得到一个初始值。

本站资源均源自网络,若涉及您的版权、知识产权或其他利益,请附上版权证明邮件告知。收到您的邮件后,我们将在72小时内删除。
若下载资源地址错误或链接跳转错误请联系站长。站长q:770044133。

» Java中的引用与ThreadLocal

发表评论

免登录下载网,提供全网最优质的资源集合!