java中强引用弱引用软引用虚引用总结

╰+哭是因爲堅強的太久メ 2023-01-01 02:54 187阅读 0赞

ThreadLocal  一个线程一个map（ThreadLocalMap）  map的key 为当前对象ThreadLocal value为对应泛型的值

ThreadLocal 的原理

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW96aHUwMzAx_size_16_color_FFFFFF_t_70][]

强引用: 平时定义变量 如 Student s = new Student(); s即强引用

软引用 SoftReference<Student>  s =  new SoftReference<>(new Student()) 定义的变量为软引用  主要用于缓存，需要新的空间的时候，可以将空间让出，即使有引用也会被强制删除 （只有空间不够用的时候，才会被清除）  
  
弱引用  WeakReference 只要垃圾回收的时候，直接删除  一般用于容器weakHashMap  ThreadLocal中有应用  中的key 是通过弱引用指向ThreadLoal

ThreadLocal set 方法

public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
        }

void createMap(Thread t, T firstValue) {
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }

ThreadLocal.ThreadLocalMap threadLocals = null;

private void set(ThreadLocal<?> key, Object value) {
    
                // We don't use a fast path as with get() because it is at
                // least as common to use set() to create new entries as
                // it is to replace existing ones, in which case, a fast
                // path would fail more often than not.
    
                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)]) {
                    ThreadLocal<?> k = e.get();
    
                    if (k == key) {
                        e.value = value;
                        return;
                    }
    
                    if (k == null) {
                        replaceStaleEntry(key, value, i);
                        return;
                    }
                }
    
                tab[i] = new Entry(key, value);
                int sz = ++size;
                if (!cleanSomeSlots(i, sz) && sz >= threshold)
                    rehash();
            }

static class Entry extends WeakReference<ThreadLocal<?>> {
          /** The value associated with this ThreadLocal. */
           Object value;
    
           Entry(ThreadLocal<?> k, Object v) {
               super(k);
               value = v;
           }
     }

ThreadLocal t = new ThreadLocal();  
        如果是强引用的话 t里面的key是强引用，当t 的强引用被回收的时候 ，那个key 不会被被回收掉  会导致内存泄漏（内存永远不会被回收）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW96aHUwMzAx_size_16_color_FFFFFF_t_70 1][]  
          
        内存泄漏：内存一直占用 不会被回收  
          
        当强引用消失的时候 那个弱引用就自动消失了    内存会被回收  
          
        但是 还有一个问题 key 指向一个null 并不是key对应的value . ThreadLocalMap  threadLocals  会越来越大 还是会导致内存泄漏，所以当引用不用了 需要remove掉  
          
        如何避免内存泄漏  remove掉  
        t.set(Student)  
        t.remove(); 删除的都是当前线程  
          
          
        ThreadLocalMap  Entry  key为空  value  value指向数据 永远取不到 value指向的内存不会被回收  还会有内存泄漏  
          
虚引用  堆外内存  
PhantomReference  创建的时候，需要写两个参数  对象Student 和队列Queue  
这个东西 我们用不到 是给写JVM的人用的或者netty 回收堆外内存即不是由JVM 管理的  
这个是完全get不到的，

分配内存的时候不想用JVM的内存，想用堆外内存，但是又想及时回收，这样就需要用虚引用  有个监测队列Queue,当JVM监测到Student被JVM回收，这时把堆外内存的数据删除掉

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW96aHUwMzAx_size_16_color_FFFFFF_t_70]: /images/20221120/017170db31a04c01a59976a1f3eaa08c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW96aHUwMzAx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201230205522245.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW96aHUwMzAx,size_16,color_FFFFFF,t_70