JAVA多线程-(十八)ThreadLocal线程局部变量和强软弱虚四种引用_局部变量是强引用还是弱引用

ThreadLocal线程局部变量

ThreadLocal是使用空间换时间，synchronized是使用时间换空间，比如在hibernate中session就存在与ThreadLocal中，避免synchronized的使用。

import java.util.concurrent.TimeUnit;
public class ThreadLocal2 {
	//volatile static Person p = new Person();
	static ThreadLocal<Person> tl = new ThreadLocal<>();
	
	public static void main(String[] args) {
				
		new Thread(()->{
			try {
				TimeUnit.SECONDS.sleep(2);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(tl.get());
		}).start();
		
		new Thread(()->{
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			tl.set(new Person());
		}).start();
	}
	
	static class Person {
		String name = "zhangsan";
	}
}
//1秒后  设置值 2秒后访问不了  因为ThreadLocal是线程独有的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

先获取到当前的线程Thread，根据当前线程获取ThreadLocalMap返回，然后再Map中set

根据当前线程获取ThreadLocalMap返回

获取当前线程的threadLocals

强引用

重写finalize，当垃圾回收会调用打印输出"finalize"

public class M {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize");
    }
}
1
2
3
4
5
6

当指向为null的时候会被回收

import java.io.IOException;

public class T01_NormalReference {
    public static void main(String[] args) throws IOException {
        M m = new M();
        m = null;
        System.gc(); //DisableExplicitGC

        System.in.read();
    }
}
//有引用指向不会垃圾回收  M m = new M(); m 强引用
1
2
3
4
5
6
7
8
9
10
11
12
13

软引用

对象被软引用指向 系统内存不够用了才会回收
存够用即使GC也不会回收软引用 内存不够清理软引用

/**
 * 软引用
 * 软引用是用来描述一些还有用但并非必须的对象。
 * 对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收。
 * 如果这次回收还没有足够的内存，才会抛出内存溢出异常。
 * -Xmx20M
 */
import java.lang.ref.SoftReference;

public class T02_SoftReference {
    public static void main(String[] args) {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024*1024*10]);//栈内存m指向堆软引用对象  软引用对象里面有个引用指向了一个字节数组
        //m = null;
        System.out.println(m.get());//拿到字节数组 输出hashcode
        System.gc();//运行垃圾回收 FullGc
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());//如果被回收会输出null

        //再分配一个数组，heap将装不下，这时候系统会垃圾回收，先回收一次，如果不够，会把软引用干掉
        byte[] b = new byte[1024*1024*15];
        System.out.println(m.get());//如果被回收会输出null
    }
}

//软引用非常适合缓存使用
//对象被软引用指向  系统内存不够用了才会回收  系统够用不会回收    内存够用即使GC也不会回收软引用   内存不够清理软引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

弱引用

弱引用遭到gc就会回收

/**
 * 弱引用遭到gc就会回收
 *
 */
import java.lang.ref.WeakReference;

public class T03_WeakReference {
    public static void main(String[] args) {
        WeakReference<M> m = new WeakReference<>(new M());

        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());//弱引用垃圾回收收掉 所以输出null

//弱引用一般用在容器里 如果有另外一个强引用指向她(new M ) 强引用消失 这个就会消失   
        ThreadLocal<M> tl = new ThreadLocal<>();
        tl.set(new M());
        tl.remove();//对象不用了要remove

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ThreadLocalMap在set(k,v)时候，k是ThreadLocal，v是期望的value

通过上图可以看出ThreadLocalMap的k是弱引用。

tl随着方法结束就会指向null,不会再指向ThreadLocal,这个时候如果k指向ThreadLocal是个强引用，ThreadLocal就会内存泄漏，线程不停止都不会回收。所以这个时候K是弱引用，遇到垃圾回收，k指向null，ThreadLocal就会被回收，但是ThreadLocal被回收，value在map,key为null,不会被使用。ThreadLocal调用remove()方法，就会完成清理。

虚引用

一个对象是否有虚引用的存在，完全不会对其生存时间构成影响， 也无法通过虚引用来获取一个对象的实例。
为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象， 那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null,弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。
jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存，
而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念）， 所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后，
会在堆内存分配一个对象保存这个堆外内存的引用， 这个对象被垃圾收集器管理，一旦这个对象被回收， 相应的用户线程会收到通知并对直接内存进行清理工作。
事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放， DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.LinkedList;
import java.util.List;

public class T04_PhantomReference {
    private static final List<Object> LIST = new LinkedList<>();
    private static final ReferenceQueue<M> QUEUE = new ReferenceQueue<>();//虚引用回收了 装入队列



    public static void main(String[] args) {


        PhantomReference<M> phantomReference = new PhantomReference<>(new M(), QUEUE);//只要有垃圾回收就把M干掉


        new Thread(() -> {
            while (true) {
                LIST.add(new byte[1024 * 1024]);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
                System.out.println(phantomReference.get());//虚引用拿不到
            }
        }).start();

        new Thread(() -> {
            while (true) {
                Reference<? extends M> poll = QUEUE.poll();
                if (poll != null) {
                    System.out.println("--- 虚引用对象被jvm回收了 ---- " + poll);
                }
            }
        }).start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

//虚引用管理堆外内存  直接内存不会被JVM管理  虚引用被垃圾回收器回收管理堆外内存
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51