精华内容
下载资源
问答
  • 强软弱虚

    2021-04-02 16:01:51
    Java中有四种引用类型:引用、软引用、弱引用、引用。 Java为什么要设计这四种引用 Java的内存分配和内存回收,都不需要程序员负责,都是由伟大的JVM去负责,一个对象是否可以被回收,主要看是否有引用指向此...

    Java中的四种引用

    Java中有四种引用类型:强引用、软引用、弱引用、虚引用。

    Java为什么要设计这四种引用

    Java的内存分配和内存回收,都不需要程序员负责,都是由伟大的JVM去负责,一个对象是否可以被回收,主要看是否有引用指向此对象,说的专业点,叫可达性分析。

    Java设计这四种引用的主要目的有两个:

    1. 可以让程序员通过代码的方式来决定某个对象的生命周期;

    2. 有利用垃圾回收。

    强引用

    强引用是最普遍的一种引用,我们写的代码,99.9999%都是强引用:

    Object o = new Object();
    
    这种就是强引用了,是不是在代码中随处可见,最亲切。
    

    只要某个对象有强引用与之关联,这个对象永远不会被回收,即使内存不足,JVM宁愿抛出OOM,也不会去回收。

    那么什么时候才可以被回收呢?当强引用和对象之间的关联被中断了,就可以被回收了。

    我们可以手动把关联给中断了,方法也特别简单:

    o = null;
    
    我们可以手动调用GC,看看如果强引用和对象之间的关联被中断了,资源会不会被回收,为了更方便、更清楚的观察到回收的情况,我们需要新写一个类,然后重写finalize方法,下面我们来进行这个实验:
    
    public class Student {    
      @Override
        protected void finalize() throws Throwable {
            System.out.println("Student 被回收了");
        }
    }
    ​
    public static void main(String[] args) {
        Student student = new Student();
        student = null;
        System.gc();
    }
    

    运行结果:

    Student 被回收了
    
    可以很清楚的看到资源被回收了。
    

    当然,在实际开发中,千万不要重写finalize方法

    在实际的开发中,看到有一些对象被手动赋值为NULL,很大可能就是为了“特意提醒”JVM这块资源可以进行垃圾回收了。

    软引用

    下面先来看看如何创建一个软引用:

     SoftReference<Student>studentSoftReference=new SoftReference<Student>(new Student());
    
    软引用就是把对象用SoftReference包裹一下,当我们需要从软引用对象获得包裹的对象,只要get一下就可以了:
    
    SoftReference<Student>studentSoftReference=new SoftReference<Student>(new Student());
    Student student = studentSoftReference.get();
    System.out.println(student);
    

    软引用有什么特点呢:

    当内存不足,会触发JVM的GC,如果GC后,内存还是不足,就会把软引用的包裹的对象给干掉,也就是只有在内存不足,JVM才会回收该对象。

    还是一样的,必须做实验,才能加深印象:

    SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[1024*1024*10]);
    System.out.println(softReference.get());
    System.gc();
    System.out.println(softReference.get());        
    byte[] bytes = new byte[1024 * 1024 * 10];
    System.out.println(softReference.get());
    

    我定义了一个软引用对象,里面包裹了byte[],byte[]占用了10M,然后又创建了10Mbyte[]。

    运行程序,需要带上一个参数: -Xmx20M

    代表最大堆内存是20M。

    运行结果:

    [B@11d7fff
    [B@11d7fff
    null
    

    可以很清楚的看到手动完成GC后,软引用对象包裹的byte[]还活的好好的,但是当我们创建了一个10M的byte[]后,最大堆内存不够了,所以把软引用对象包裹的byte[]给干掉了,如果不干掉,就会抛出OOM。

    软引用到底有什么用呢?比较适合用作缓存,当内存足够,可以正常的拿到缓存,当内存不够,就会先干掉缓存,不至于马上抛出OOM。

    弱引用

    弱引用的使用和软引用类似,只是关键字变成了WeakReference:

    WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1024\*1024\*10]);
    System.out.println(weakReference.get());
    

    弱引用的特点是不管内存是否足够,只要发生GC,都会被回收:

    WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1]);
    System.out.println(weakReference.get());
    System.gc();
    System.out.println(weakReference.get());
    

    运行结果:

    [B@11d7fffnull
    
    可以很清楚的看到明明内存还很充足,但是触发了GC,资源还是被回收了。  弱引用在很多地方都有用到,比如ThreadLocal、WeakHashMap。
    

    虚引用

    虚引用又被称为幻影引用,我们来看看它的使用:

    ReferenceQueue queue = new ReferenceQueue();
    PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);
    System.out.println(reference.get());
    

    虚引用的使用和上面说的软引用、弱引用的区别还是挺大的,我们先不管ReferenceQueue 是个什么鬼,直接来运行:

    null
    
    竟然打印出了null,我们来看看get方法的源码:
    
    public T get() {        
      return null;
    }
    

    ???,竟然直接返回了null。

    这就是虚引用特点之一了:无法通过虚引用来获取对一个对象的真实引用。

    那虚引用存在的意义是什么呢?这就要回到我们上面的代码了

    创建虚引用对象,我们除了把包裹的对象传了进去,还传了一个ReferenceQueue,从名字就可以看出它是一个队列。

    虚引用的特点之二就是 虚引用必须与ReferenceQueue一起使用,当GC准备回收一个对象,如果发现它还有虚引用,就会在回收之前,把这个虚引用加入到与之关联的ReferenceQueue中。

    我们来用代码实践下吧:

     

    运行结果:

    Student 被回收了
    虚引用被回收了:java.lang.ref.PhantomReference@1ade6f1
    

    我们简单的分析下代码: 第一个线程往集合里面塞数据,随着数据越来越多,肯定会发生GC。 第二个线程死循环,从queue里面拿数据,如果拿出来的数据不是null,就打印出来。

    从运行结果可以看到:当发生GC,虚引用就会被回收,并且会把回收的通知放到ReferenceQueue中。

    虚引用有什么用呢?在NIO中,就运用了虚引用管理堆外内存。

    展开全文
  • Java中的类型引用强软弱虚强引用栈内存指向了堆内存public class MGCTest {public static void main(String[] args) {M m = new M();m = null;System.gc();}}复制代码当栈内存的m指向堆内存的new M(),当m=null是gc...

    Java中的类型引用

    强软弱虚

    强引用

    栈内存指向了堆内存

    public class MGCTest {

    public static void main(String[] args) {

    M m = new M();

    m = null;

    System.gc();

    }

    }

    复制代码

    当栈内存的m指向堆内存的new M(),当m=null是gc触发就会把new M()回收。

    软引用

    先示例

    /**

    * create by yanghongxing on 2020/5/19 11:48 下午

    */

    public class SoftReferenceM {

    public static void main(String[] args) throws InterruptedException {

    SoftReference m = new SoftReference<>(new byte[1024 * 1024 * 10]);

    System.out.println(m.get());

    System.gc();

    System.out.println(m.get());

    SoftReference n = new SoftReference<>(new byte[1024 * 1024 * 11]);

    System.out.println(m.get());

    ThreadLocal mThreadLocal = new ThreadLocal<>();

    mThreadLocal.set(new M());

    mThreadLocal.get();

    }

    }

    复制代码

    我先创建了一个弱引用,这里的引用关系时第一步创建了一个SoftReference对象,第二步创建了一个byte对象,第三 步将将SoftReference通过弱引用指向byte对象,最后将m通过强引用指向SoftReference对象。我们设置一个jvm参数-Xmx20m,将堆内存设置最大值为20m。输出结果为:

    [B@372f7a8d

    [B@372f7a8d

    null

    复制代码

    因为我们把堆内存设置成最大值20m,第一次创建了一个10m的byte数组,第二次创建了一个11m的byte数组,第二次创建的时候堆内存不够用,就回收了之前10m的数组。

    弱引用

    public class WeakReferenceM {

    public static void main(String[] args) {

    WeakReference m = new WeakReference<>(new M());

    System.out.println(m.get());

    System.gc();

    System.out.println(m.get());

    }

    }

    复制代码

    输出结果:

    com.example.demo.quote.M@372f7a8d

    null

    finalize

    复制代码

    弱引用垃圾回收器看到就会被回收。弄清楚弱引用先了解一下什么是ThreadLocal,是个本地线程对象,线程存在这个对象就存在,比如在spring的Transactional注解,在为了保证事务不同的方法中获取的必须是同一个连接对象,这个连接对象就被保存咋ThreadLocal中。我们看看ThreadLocal的源码。

    /**

    * Sets the current thread's copy of this thread-local variable

    * to the specified value. Most subclasses will have no need to

    * override this method, relying solely on the {@link #initialValue}

    * method to set the values of thread-locals.

    *

    * @param value the value to be stored in the current thread's copy of

    * this thread-local.

    */

    public void set(T value) {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null)

    map.set(this, value);

    else

    createMap(t, value);

    }

    复制代码

    首先拿到当前线程对象,然后获取了个map,然后往这个map中放了当前对象,这个this就是ThreadLocal对象

    /**

    * Get the map associated with a ThreadLocal. Overridden in

    * InheritableThreadLocal.

    *

    * @param t the current thread

    * @return the map

    */

    ThreadLocalMap getMap(Thread t) {

    return t.threadLocals;

    }

    复制代码

    t.threadLocals,t是Thread对象,Thread对象的一个成员变量。我们再看看set方法的源码

    /**

    * Set the value associated with key.

    *

    * @param key the thread local object

    * @param value the value to be set

    */

    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();

    }

    复制代码

    这个构造了个Entry对象,这个Entry可以看成是map的一行数据,一个key-value对。再看看Entry的源码。

    static class Entry extends WeakReference> {

    /** The value associated with this ThreadLocal. */

    Object value;

    Entry(ThreadLocal> k, Object v) {

    super(k);

    value = v;

    }

    }

    复制代码

    这个Entry对象竟然是继承了WeakReference对象。所以弱引用的典型应用就是ThreadLocal中。94cabd633fb6140ceaa907869fbf083e.png

    上面的用图画出来就是这个样子,Thread对象中存了一个强引用指向ThreadLocal就是ThreadLocal mThreadLocal = new ThreadLocal<>()句代码,同时Thread中还有个ThreadLocalMap,这个map的key就是指向ThreadLocal对象,这个对象使用的是弱引用,使用弱引用的原因是防止内存泄漏。既然这里使用的是弱引用为啥ThreadLocal还那么容易产生内存泄漏呢?我们看key是弱引用,但是value不是,所以这个记录还是在map中,所以容易产生内存泄漏,为了防止内存泄漏,我们就在ThreadLocal使用完就remove掉。

    虚引用

    public class PhontamReferenceM {

    private static ReferenceQueue QUEUE = new ReferenceQueue<>();

    private static List LIST = new ArrayList();

    public static void main(String[] args) {

    PhantomReference m = new PhantomReference<>(new M(), QUEUE);

    new Thread(() -> {

    while (true) {

    LIST.add(new byte[1024 * 1024]);

    try {

    Thread.sleep(50);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("0" + m.get());

    }

    }).start();

    new Thread(() -> {

    while (true) {

    Reference extends M> poll = QUEUE.poll();

    if (Objects.nonNull(poll)) {

    System.out.println("1" + poll);

    }

    }

    }).start();

    }

    }

    复制代码

    输出为:

    0null

    1java.lang.ref.PhantomReference@b148489

    0null

    0null

    0null

    0null

    复制代码

    虚引用的主要作用是管理堆外内存, 比如nio操作为了提高效率就可能有部分内存放在堆外,堆外内存不能直接被GC回收,可能当对象被回收时,通过Queue可以检测到,然后清理堆外内存。

    b739ec46bb5c46d9c0aa4ce35ba1ea56.png

    关于找一找教程网

    本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。

    本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。

    [Java中的强软弱虚引用]http://www.zyiz.net/tech/detail-136440.html

    展开全文
  • java中的引用类型共4种:强软弱虚,具体每种类型的特点和应用场景。记录下。本文是看了马士兵老师的视频后记录整理的。加深印象。基本概念1. 强引用强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器...

    java中的引用类型共4种:强软弱虚,具体每种类型的特点和应用场景。记录下。本文是看了马士兵老师的视频后记录整理的。加深印象。

    基本概念

    1. 强引用

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足时,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。

    97f64949996e23ce8bc7ad127de5fcea.png

    显式地设置M对象为null,或让其超出对象的生命周期范围,则gc认为该对象不存在引用,这时就可以回收这个对象

    示例代码

    声明一个M类

    public class M {

    /**

    * 当这个对象会被回收的时候,finalize会被调用

    *

    * @throws Throwable

    */

    @Override

    protected void finalize() throws Throwable {

    System.out.println("finalize");

    }

    }

    强引用调用

    public class NormalReference {

    public static void main(String[] args) throws IOException {

    M m = new M();

    m = null;

    System.gc();

    // 如果不写 main方法退出。System.gc()在垃圾回收线程里;

    // 有可能还没来得及回收main方法就退出了

    System.in.read();

    }

    }

    输出结果

    finalize

    2. 软引用

    软引用对象是在jvm内存不够的时候才会被回收

    4f727f2b752b0f911c862124aba818ed.png

    代码示例

    public class Soft {

    public static void main(String[] args) {

    System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);

    //10m

    SoftReference m = new SoftReference<>(new byte[1024 * 1024 * 10]);

    System.out.println(m.get());

    System.gc();

    try {

    Thread.sleep(1500);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println(m.get());

    // 再分配一个数组,heap装不下去,这时候系统会垃圾回收,

    // 先回收一次,如果不够,会把软引用回收

    byte[] b = new byte[1024 * 1024 * 11];

    System.out.println(m.get());

    }

    }

    设置程序运行参数:-Xmx20M

    运行结果

    19

    [B@1540e19d

    [B@1540e19d

    null

    我们可以看到,这个时候已经被回收了。

    应用场景:软引用时候做缓存

    3. 弱引用

    弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存

    代码示例

    public class Weak {

    public static void main(String[] args) {

    WeakReference m = new WeakReference<>(new M());

    System.out.println(m.get());

    System.gc();

    System.out.println(m.get());

    }

    }

    执行结果

    M@1540e19d

    null

    finalize

    4. 虚引用

    如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

    虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

    f8a112c609649bf24ad083539e0473d8.png

    示例

    public class Phantom {

    private static final List LIST = new LinkedList<>();

    private static final ReferenceQueue QUEUE = new ReferenceQueue<>();

    public static void main(String[] args) {

    PhantomReference phantomReference = new PhantomReference<>(new M(), QUEUE);

    new Thread(

    () -> {

    while (true) {

    LIST.add(new byte[1024 * 1024]);

    try {

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    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();

    }

    }

    运行结果

    finalize

    null

    Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space

    at Phantom.lambda$main$0(Phantom.java:18)

    at Phantom$$Lambda$1/1078694789.run(Unknown Source)

    at java.lang.Thread.run(Thread.java:748)

    -------虚引用对象被jvm回收了------java.lang.ref.PhantomReference@688ee48d

    应用场景:堆外内存的管理

    总结

    aa155f5dbce1428b3c2291a5dfa2899f.png

    展开全文
  • 前言java中的引用类型共4种:强软弱虚,具体每种类型的特点和应用场景。记录下。本文是看了马士兵老师的视频后记录整理的。加深印象。基本概念1. 强引用强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾...

    前言

    java中的引用类型共4种:强软弱虚,具体每种类型的特点和应用场景。记录下。本文是看了马士兵老师的视频后记录整理的。加深印象。

    基本概念

    1. 强引用

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足时,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。

    aadf31aeda4548943cb84d59e8c7131c.png

    显式地设置M对象为null,或让其超出对象的生命周期范围,则gc认为该对象不存在引用,这时就可以回收这个对象

    示例代码

    声明一个M类

    public class M {

    /**

    * 当这个对象会被回收的时候,finalize会被调用

    *

    * @throws Throwable

    */

    @Override

    protected void finalize() throws Throwable {

    System.out.println("finalize");

    }

    }

    强引用调用

    public class NormalReference {

    public static void main(String[] args) throws IOException {

    M m = new M();

    m = null;

    System.gc();

    // 如果不写 main方法退出。System.gc()在垃圾回收线程里;

    // 有可能还没来得及回收main方法就退出了

    System.in.read();

    }

    }

    输出结果

    finalize

    2. 软引用

    软引用对象是在jvm内存不够的时候才会被回收

    79df33f8dd4254accd43c334714b29e1.png

    代码示例

    public class Soft {

    public static void main(String[] args) {

    System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);

    //10m

    SoftReference m = new SoftReference<>(new byte[1024 * 1024 * 10]);

    System.out.println(m.get());

    System.gc();

    try {

    Thread.sleep(1500);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println(m.get());

    // 再分配一个数组,heap装不下去,这时候系统会垃圾回收,

    // 先回收一次,如果不够,会把软引用回收

    byte[] b = new byte[1024 * 1024 * 11];

    System.out.println(m.get());

    }

    }

    设置程序运行参数: -Xmx20M

    运行结果

    19

    [B@1540e19d

    [B@1540e19d

    null

    我们可以看到,这个时候已经被回收了。

    应用场景:软引用时候做缓存

    3. 弱引用

    弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存

    代码示例

    public class Weak {

    public static void main(String[] args) {

    WeakReference m = new WeakReference<>(new M());

    System.out.println(m.get());

    System.gc();

    System.out.println(m.get());

    }

    }

    执行结果

    M@1540e19d

    null

    finalize

    4. 虚引用

    如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

    虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

    738b89c55f21fcb94c5fd0aa09978257.png

    示例

    public class Phantom {

    private static final List LIST = new LinkedList<>();

    private static final ReferenceQueue QUEUE = new ReferenceQueue<>();

    public static void main(String[] args) {

    PhantomReference phantomReference = new PhantomReference<>(new M(), QUEUE);

    new Thread(

    () -> {

    while (true) {

    LIST.add(new byte[1024 * 1024]);

    try {

    Thread.sleep(1000);

    } catch (InterruptedException e) {

    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();

    }

    }

    运行结果

    finalize

    null

    Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space

    at Phantom.lambda$main$0(Phantom.java:18)

    at Phantom$$Lambda$1/1078694789.run(Unknown Source)

    at java.lang.Thread.run(Thread.java:748)

    -------虚引用对象被jvm回收了------java.lang.ref.PhantomReference@688ee48d

    应用场景:堆外内存的管理

    总结

    到此这篇关于java中引用类型之强软弱虚的文章就介绍到这了,更多相关java引用类型之强软弱虚内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持!

    展开全文
  • 强软弱虚引用

    2020-01-10 14:21:20
    文章目录强软弱虚引用强引用软引用内存充足内存不足适用场景弱引用WeakHashMap虚引用引用队列虚引用和引用队列总结 强软弱虚引用 强引用 当内存不足,JVM开始垃圾回收,对于强引用的对象,就算是出现了OOM也不会对该...
  • Java强软弱虚

    2021-03-13 17:25:09
    我们一般记忆为强软弱虚这个词语。 java 为什么要区分四种引用? 程序运行的空间是有限的,我们希望内存空间占满时,能够清理一部分不重要的数据。四种引用方式对应着四种内存清理优先级,如此一来,便可节约较多的...
  • Java强软弱虚引用

    2020-03-31 15:35:59
    文章目录Java强软弱虚引用强引用软引用弱引用虚引用 Java强软弱虚引用 强引用 Object obj = new Object() 。这个obj就是一个强引用,jvm不会在垃圾回收的时候对这些引用回收,选择OutOfMemoryError 终止程序 软...
  • 强软弱虚java中的数据被类型分为了两类,它们分别是基本类型和引用类型。一般我们new出来的对象都属于引用类型的范畴。我们知道java是有垃圾回收机制的一种语言,根据垃圾回收时的策略,java将对于堆对象的引用又...
  • jvm之强软弱虚引用

    万次阅读 2020-07-16 19:58:56
    强软弱虚引用 在java中,除了基本数据类型的变量外,其他所有的变量都是引用类型,指向堆上各种不同的对象。 在jvm中,除了我们常用的强引用外,还有软引用、弱引用、虚引用,这四种引用类型的生命周期与jvm的垃圾...
  • 强软弱虚四大引用

    2021-04-07 18:44:01
    强软弱虚四大引用1 概述2 强引用2.1 垃圾回收方式2 .2 代码实例3 软引用3.1 垃圾回收方式3.2 代码实例4 弱引用4.1 垃圾回收方式4.2 代码实例4.3 使用场景4.4 WeakHashMap4.4.1 代码示例5 虚引用5.1 回收方式5.2 代码...
  • Java 强软弱虚引用

    2019-10-04 12:23:59
    Java 强软弱虚引用 Java 根据对象的引用方式可以分为:强引用、软引用、弱引用、虚引用。 即 SoftReference、WeakReference、PhantomReference。 SoftReference、WeakReference、PhantomReference 位于 java.lang....
  • JVM 强软弱虚引用

    2020-06-28 14:31:16
    强软弱虚 强引用: Object obj = new Object(); 当内存空间满了之后 obj 也不会被回收 可以使用 obj = null; 让垃圾回收器进行回收 软引用: SoftReference softReference = new SoftReference(new Object()); 只有当...
  • 主要给大家介绍了关于java中引用类型之强软弱虚的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 引用:强软弱虚

    2020-12-02 16:14:12
    引用:强软弱虚 分类 强,软,弱,虚。 强引用 存在引用则不回收,即使OOM。 T t = new T(); // 使用 // 回收:t置为null,下次GC原来指向的对象如果没有其他引用,会被回收 t = null; 软引用 内存不够,GC会回收...
  • 强软弱虚引用.

    2020-10-19 22:33:45
    强软弱虚引用. 强引用: 他是我们最常见的引用object o=new Object();这个就是强引用.当我们修改他为null时他才可能被回收.o=null;因为他不存在指向了. 软引用: 垃圾回收器,内存不够的时候回收. 使用软引用需要导包....
  • 强软弱虚四种引用

    2020-11-22 20:31:52
    java中四种引用,强软弱虚 强引用: 只要有引用指向某个对象,这个对象就不会被回收=====这个就是最普通的new Object() 软引用: 这个可以用在缓存中,数据都放在里面,允许内存不够的情况下把这个数据...
  • java引用:强软弱虚

    2019-09-29 15:55:23
    java引用:强软弱虚 public static void main(String[] args) throws IOException { /** * 强引用:默认的引用。只要有引用指向这个对象,垃圾回收一定不会回收他 */ User user = new User(); //使user不在...
  • 引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、引用(Phantom Reference)总结:引用:不管内存够不够都不会被回收(我们平时new创建对象就是引用)软引用:内存够用不回收,不够用...
  • 强软弱虚四种引用 1.强 User u = new User() 正常写的引用都是强引用,JVM会根据是否可达判断是否要回收。 2.软 SoftReference<byte[]> res = new SoftReference<>(new byte[1024]); res里面的byte...
  • Java中的强软弱虚引用

    2020-11-02 19:48:01
    Java中的强软弱虚引用 强引用 强引用内存示意图: Java中最普遍的引用,比如有个A类,我们使用new关键字去创建A的实例的时候 A a = new A(); 栈中变量a指向堆中A的实例这个引用就是强引用。 public class ...
  • 因此,在JDK1.2之后Java对引用的概念进行了扩充,将引用分为引用(Strong Reference),软引用(Soft Reference),弱引用(Weak Reference),引用(Phantom Reference)4种 这4种引用强度依次逐渐减弱。这里的引用...
  • Java的四种引用类型-强软弱虚强引用软引用弱引用虚引用 强引用 软引用 弱引用 虚引用
  • 软引用、弱引用、引用,全都继承自同一个抽象类,这个抽象类Reference,这个抽象类实现了引用类的主要方法,另外三个对它的扩展很少。看了一下 java 8 的源码软引用只是添加了个时间戳,弱引用什么都没添加,虚引...
  • JVM基础总结02 - JVM进阶之强软弱虚引用 一、强软弱虚引用 位于java.lang.ref包 1.强引用 代码示例 public class StrongReferenceDemo { public static void main(String[] args) { Object o1 = new Object();...
  • 强软弱虚四大引用详解及作用 整体架构 强引用 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OOM,也不会靠随意回收具有强引用的对象来解决...
  • 什么是强软弱虚? 强引用就是普通的new出来的对象,当没有引用再指向它时,它才会被GC回收,否则哪怕内存溢出也不会被GC回收,当然如果将引用重新赋值为null,则该引用对象就不再是强引用了 软引用是当将要发生内存...
  • 展开全部Java中四种引32313133353236313431303231363533e58685e5aeb931333365633930用的特点:引用(StrongReference)当我们使用 new 这个关键字创建对象时创建出来的对象就是引用(new出来对象为引用) 如Object...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 513
精华内容 205
关键字:

强软弱虚