精华内容
下载资源
问答
  • 很早Java API就添加了弱引用(WeakReference)和软引用(SoftReference),但并不是所有的程序员都熟悉这两个概念
  • 原文地址:http://javarevisited.blogspot.jp/2014/03/difference-between-weakreference-vs-softreference-phantom-strong-reference-java.html (可能需要梯子才能看到) 首先,由于这是我的第一篇翻译文章,再...

    原文地址:http://javarevisited.blogspot.jp/2014/03/difference-between-weakreference-vs-softreference-phantom-strong-reference-java.html (可能需要梯子才能看到)

    首先,由于这是我的第一篇翻译文章,再加上我的英语水平和技术水平有限在翻译上难免会有不妥之处,敬请见谅。

    弱引用(WeakReference)和软引用(softReference)被加入到java api中已经很长一段时间了,但并不是每一位java 程序员都对它们很熟悉。也就意味着在哪和怎么使用弱引用和软引用之间有一道间隙。引用类(Reference Classes)在文章《GC 如何工作》中特别重要。我们都知道GC回从那些应该被回收的对象上回收内存,但是不是很多的程序员知道这个“应该”是基于什么样的引用指向这个对象来决定的。这也是Java中的软引用和弱引用的主要不同。GC很可能回收一个对象,如果它只有弱引用指向它,另一方面,当java虚拟机特别需要内存的时候,那些软引用的对象只能眼巴巴的被回收。软引用和弱引用的这些特别的行为让它们在一些特定的场景特别有用。例如:软引用用于做缓存看起来特别棒,所以当java虚拟机需要内存的时候它把那些只有软引用指向的对象随意出。而相对应的弱应用用于保存元数据(Meta data)特别棒。例如:保存ClassLoader的引用,如果没有类被加载那么就没有指针保持ClassLoader的引用,一个弱引用让ClassLoader能够在强引用被移除时立刻被GC回收。在这篇文章中我们会探讨更多java中各种引用如:强引用和虚引用。

    WeakReference vs. SoftReference

    为那些不知道java中有四种引用的同学:

    1.强引用(Strong Reference)

    2.弱引用(Weak Reference)

    3.软引用 (Soft Reference)

    4.虚引用 (Phantom Reference)

    强引用是我们每天编程生活中使用最简单的,例如:在代码 String s = “abc”,引用对象s有一个强引用一个String对象 “abc”。任何有强引用的对象都不应该被GC回收。显然这些是java程序需要的对象。弱引用用java.lang.ref.WeakReference类表示,你可以通过使用以下代码创建一个弱引用:

    Counter counter = new Counter(); //强引用 line 1
    
    WeakReference<Counter> weakCounter = new WeakReference<Counter>(counter);//弱引用
    
    counter = null;//现在Counter对象能够被GC回收了
    现在,一旦你让强引用counter = null,line 1被创建的对象变成了可被GC回收了。因为它没有任何的强引用并且被引用对象weakCounter弱引用不能阻止Counter对象被GC回收。另一方面,如果它被软引用着,Counter对象将不会被回收直到ava虚拟机特别需要内存。软引用在java中用java.lang.ref.SoftReference类表示。你可以通过以下代码创建一个软引用:

    Counter prime = new Counter();//prime 持有一个强引用 line 2
    
    SoftReference<Counter> soft = new SoftReference<Counter>(prime);// 软引用变量有一个指向line 2倍创建的Counter 对象
    
    prime = null ; //现在Counter对象只有在jvm特别需要内存的时候才会被回收

    让强引用变成null之后,line2创建的Counter对象只有一个不能阻止它被垃圾回收但是能延迟回收的软引用,而在弱引用的情况下会更快。由于软引用和弱引用这个主要不同,软引用更适合于做缓存,而弱引用韩庚适合保存元数据。一个弱引用的例子是WeakHashMap,它是像HashmMap或者TreeMap的其他的Map接口的实现,但是它有一个独一无二的特性:WeakHashMap把它的key包装成弱引用也就是意味着一旦真是对象的强引用被移除,在WeakHashMap内部的弱引用不能保证他们不被垃圾回收。

    虚引用是在java.lang.ref包中可以得到的第三种引用。虚引用用java.lang.ref.PhantomReference类表示。那些虚引用指向的对象可以随时被回收如果gc喜欢。与弱引用和软引用相似的,你可以通过以下代码创建一个虚引用:


    DigitalCounter digit = new DigitalCounter();//digit 引用变量有一个强引用 line3 
    
    PhantomReference<DigitalCounter> phantom = new PhantomReference<DigitalCounter>(digit);//line3 创建的对象的虚引用
    
    digit = null;


    一旦你移除了强引用,由于只有一个不能阻止被回收的虚引用指向他,line3创建的对象能随时被垃圾回收。

    除了,熟知的WeakReference,SoftReference,PhantomReference和WeakHashMap,还有一个叫ReferenceQueue的类很值得了解。当创建任何弱引用,软引用和虚引用时,你可以提供一个ReferenceQueue的实例,如下面代码展示的一样:


    ReferenceQueue reQueue= new ReferenceQueue();// 引用会被保存在这个队列中来清理
    
    DigitalCounter = digit =new DigitalCounter();
    
    PhantomReference<DigitalCounter> phantom = new PhantomReference<DigitalCounter>(digit,reQueue);

    引用的实例会被追加到ReferenceQueue里,你可以使用它进行任何清理通过poll 引用队列,一个对象的生命周期通过下面的图能得到很好的总结:


    这就是java中弱引用和软引用所以的不同了。我们也学习到了一些基本的引用类,如java中的弱引用,软引用和虚引用,还有WeakHashMap,ReferenceQueue.小心使用引用能帮助垃圾回收期更好的工作和得到更好的java内存管理。

    谢谢,大家以上就是这篇文章的内容。如果有什么翻译不好的地方欢迎在评论中告诉我。

    展开全文
  • Java弱引用详解

    千次阅读 2017-06-12 23:50:31
    强引用就是指在程序代码之中普遍存在的,类似“Object obj=new Object()”这类的引 用,只要强引用还存在,垃圾收集器永远不会回收掉被引用的对象。   弱引用也是用来描述非必需对象...弱引用和强引用看似是两个不

      强引用就是指在程序代码之中普遍存在的,类似“Object obj=new Object()”这类的引
    用,只要强引用还存在,垃圾收集器永远不会回收掉被引用的对象。  
      弱引用也是用来描述非必需对象的,但是它的强度比软引用更弱一些,被弱引用关联的
    对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时,无论当前内存是否足够,
    都会回收掉只被弱引用关联的对象
    弱引用和强引用看似是两个不同的关系,但是实际情况中只要一个对象只要被强引用关联,则不管他是否被弱引用关联、还是被软引用关联,这个对象只会表现出强引用的特性
    看代码:

    public class Test {
        //A、B是两个最普通的POJO
        public static void main(String[] args) throws InterruptedException {
            B b1 = new B();
            A a1 = new A("a1",b1);
            WeakReference<A> weakReference2 = new WeakReference<A>(a2);
            Thread.sleep(20000);
            System.out.println("回收结束  weakReference1:"+ weakReference1.get());
        }
    }

    这里写图片描述
    采用jconsole观察内存变化,手动触发gc之后,可以看到输出结果中弱引用关联的的A类的实例对象还没有被释放,这就证明了上句中当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。

    但是一旦代码稍稍修改一下就可以看出弱引用的作用了:

    public class Test {
    
        public static void main(String[] args) throws InterruptedException {
            B b1 = new B();
            A a1 = new A("a1",b1);
            WeakReference<A> weakReference1 = new WeakReference<A>(a1);
            //消除a1的强引用
            a1 = null;
            Thread.sleep(20000);
            System.out.println("回收结束  weakReference1:"+ weakReference1.get());
        }
    }
    

    这里写图片描述
    可以看到JVM进行了GC之后,输出结果中弱引用关联的A类的实例对象被释放,这就证明了上句中当垃圾收集器工作时,无论当前内存是否足够,都会回收掉只被弱引用关联的对象。

    以上仅仅是介绍了什么是弱引用但是我们依旧不知道这种引用有什么作用,那么我就给大家介绍一下ThreadLocal中弱引用的使用:

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

    可以看出来ThreadLocal中value是存储在ThreadLocalMap中的,众所周知的是ThreadLocalMap是有多个Entry组成的,

    static class ThreadLocalMap {
    
            /**
             * The entries in this hash map extend WeakReference, using
             * its main ref field as the key (which is always a
             * ThreadLocal object).  Note that null keys (i.e. entry.get()
             * == null) mean that the key is no longer referenced, so the
             * entry can be expunged from table.  Such entries are referred to
             * as "stale entries" in the code that follows.
             */
            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,也就是说一个ThreadLocalMap发生了哈希冲突的时候原有Entry被替换之后,即不存在强引用指向原来的Entry,因此该Entry在下次GC的时候就会被回收,这大大减少了频繁的哈希冲突之后产生的垃圾碎片。以上ThreadLocalMap的源码是基于JDK1.8的,有兴趣的同学可以自己去看看源码,ThreadLocalMap处理哈希冲突的方式是开放定址法,不是传统的链路法,明白这个看起来就简单很多

    展开全文
  • 引用和强引用

    2016-05-06 21:24:34
    Java中,虽然不需要程序员手动去管理对象的生命周期,但是如果希望某些对象具备一定的生命周期的话(比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误)就需要用到软引用和弱引用了。  从Java ...

     在Java中,虽然不需要程序员手动去管理对象的生命周期,但是如果希望某些对象具备一定的生命周期的话(比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误)就需要用到软引用和弱引用了。

      从Java SE2开始,就提供了四种类型的引用:强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的:第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。下面来阐述一下这四种类型引用的概念:

      1.强引用(StrongReference)

      强引用就是指在程序代码之中普遍存在的,比如下面这段代码中的object和str都是强引用:

          

    Object object = new Object();
    String str = "hello";

        只要某个对象有强引用与之关联,JVM必定不会回收这个对象,即使在内存不足的情况下,JVM宁愿抛出OutOfMemory错误也不会回收这种对象。比如下面这段代码:

     

        

    public class Main {
        public static void main(String[] args) {
            new Main().fun1();
        }
         
        public void fun1() {
            Object object = new Object();
            Object[] objArr = new Object[1000];
        }
    }

      当运行至Object[] objArr = new Object[1000];这句时,如果内存不足,JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是,当fun1运行完之后,object和objArr都已经不存在了,所以它们指向的对象都会被JVM回收。

     

      如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

      比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的:

          

    /**
         * Removes the element at the specified position in this Vector.
         * Shifts any subsequent elements to the left (subtracts one from their
         * indices).  Returns the element that was removed from the Vector.
         *
         * @throws ArrayIndexOutOfBoundsException if the index is out of range
         *         ({@code index < 0 || index >= size()})
         * @param index the index of the element to be removed
         * @return element that was removed
         * @since 1.2
         */
        public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        Object oldValue = elementData[index];
    
        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
        elementData[--elementCount] = null; // Let gc do its work
    
        return (E)oldValue;
        }

       2.软引用(SoftReference)

     

      软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象,只有在内存不足的时候JVM才会回收该对象。因此,这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。

      软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。下面是一个使用示例:

       

    import java.lang.ref.SoftReference;
     
    public class Main {
        public static void main(String[] args) {
             
            SoftReference<String> sr = new SoftReference<String>(new String("hello"));
            System.out.println(sr.get());
        }
    }

     3.弱引用(WeakReference)

     

      弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.lang.ref.WeakReference类来表示。下面是使用示例:

      

    import java.lang.ref.WeakReference;
     
    public class Main {
        public static void main(String[] args) {
         
            WeakReference<String> sr = new WeakReference<String>(new String("hello"));
             
            System.out.println(sr.get());
            System.gc();                //通知JVM的gc进行垃圾回收
            System.out.println(sr.get());
        }
    }

     

    输出结果为:
    
    
    hello
    null

     第二个输出结果是null,这说明只要JVM进行垃圾回收,被弱引用关联的对象必定会被回收掉。不过要注意的是,这里所说的被弱引用关联的对象是指只有弱引用与之关联,如果存在强引用同时与之关联,则进行垃圾回收时也不会回收该对象(软引用也是如此)。

     

      弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。

    4.虚引用(PhantomReference)

      虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。

      要注意的是,虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

     

    import java.lang.ref.PhantomReference;
    import java.lang.ref.ReferenceQueue;
     
     
    public class Main {
        public static void main(String[] args) {
            ReferenceQueue<String> queue = new ReferenceQueue<String>();
            PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
            System.out.println(pr.get());
        }
    }

     以上内容摘自:http://www.cnblogs.com/dolphin0520/p/3784171.html

     

      下面自己写一个程序测试一下,分配虚拟机10M内存,然后创建10个1M的对象放到value为SoftReference的map里面,观察是否会进行对象回收。

       

    /**
     * -XX:+PrintGCDateStamps -XX:+PrintGCDetails -Xms10M -Xmx10M
     */
    package reference;
    
    import java.lang.ref.SoftReference;
    import java.util.HashMap;
    import java.util.Map;
    
    public class SoftReferenceTest {
    
    	private static Map<String, SoftReference<byte[]>> map = new HashMap<String, SoftReference<byte[]>>();
    
    	private static final int _1MB = 1024 * 1024;
    
    	private static byte[] temp;
    
    	public static void createSoftReference(int size) {
    
    		for (int i = 0; i < size; i++) {
    			temp = new byte[_1MB];
    			System.out.println(i + ": " + temp.toString());
    			map.put(i + "", new SoftReference<byte[]>(temp));
    		}
    
    	}
    
    	public static void main(String[] args) {
    		int size = 10;
    		SoftReferenceTest.createSoftReference(size);
    		System.out.println("**********************************");
    		System.gc();
    		for (int i = 0; i < size; i++) {
    			if (null == map.get(i + "").get()) {
    				System.out.println(i + ": " + "null");
    			} else {
    				System.out.println(i + ": " + map.get(i + "").get().toString());
    			}
    		}
    	}
    }
    

      输出为:

     

       

    0: [B@1fc4bec
    1: [B@dc8569
    2016-05-06T21:00:39.126+0800: [GC [DefNew: 2331K->158K(3072K), 0.0022560 secs] 2331K->2206K(9920K), 0.0022782 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    2: [B@150bd4d
    3: [B@1bc4459
    2016-05-06T21:00:39.129+0800: [GC [DefNew: 2237K->158K(3072K), 0.0013200 secs] 4285K->4254K(9920K), 0.0013378 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    4: [B@6e1408
    5: [B@e53108
    2016-05-06T21:00:39.130+0800: [GC [DefNew: 2281K->158K(3072K), 0.0012987 secs] 6377K->6302K(9920K), 0.0013173 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    6: [B@19189e1
    7: [B@1f33675
    2016-05-06T21:00:39.132+0800: [GC [DefNew: 2219K->2219K(3072K), 0.0000063 secs][Tenured: 6144K->6144K(6848K), 0.0031130 secs] 8364K->8350K(9920K), [Perm : 2096K->2096K(12288K)], 0.0031569 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] 
    2016-05-06T21:00:39.135+0800: [Full GC [Tenured: 6144K->1169K(6848K), 0.0036361 secs] 8350K->1169K(9920K), [Perm : 2096K->2090K(12288K)], 0.0036682 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    8: [B@1690726
    9: [B@5483cd
    **********************************
    2016-05-06T21:00:39.139+0800: [Full GC (System) [Tenured: 1169K->3217K(6848K), 0.0033829 secs] 3226K->3217K(9920K), [Perm : 2090K->2090K(12288K)], 0.0034101 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    0: null
    1: null
    2: null
    3: null
    4: null
    5: null
    6: null
    7: [B@1f33675
    8: [B@1690726
    9: [B@5483cd
    Heap
     def new generation   total 3072K, used 60K [0x03ad0000, 0x03e20000, 0x03e20000)
      eden space 2752K,   2% used [0x03ad0000, 0x03adf3f8, 0x03d80000)
      from space 320K,   0% used [0x03dd0000, 0x03dd0000, 0x03e20000)
      to   space 320K,   0% used [0x03d80000, 0x03d80000, 0x03dd0000)
     tenured generation   total 6848K, used 3217K [0x03e20000, 0x044d0000, 0x044d0000)
       the space 6848K,  46% used [0x03e20000, 0x041447c0, 0x04144800, 0x044d0000)
     compacting perm gen  total 12288K, used 2096K [0x044d0000, 0x050d0000, 0x084d0000)
       the space 12288K,  17% used [0x044d0000, 0x046dc0a0, 0x046dc200, 0x050d0000)
    No shared spaces configured.
    

     

    展开全文
  • 强引用 是指创建一个对象并把这... 软引用的对象当系统内存充足时和强引用没有太多区别,但内存不足时会回收软引用的对象。注:当系统内存充足时,系统不会进行软引用的内存回收, 当系统不足时将会回收软引用的对象。
    1. 强引用
      是指创建一个对象并把这个对象赋给一个引用变量;
      强引用有引用变量指向时永远不会被垃圾回收,即使内存不足的时候。

    2.软引用
    软引用通过SoftReference类来实现
    软引用的对象当系统内存充足时和强引用没有太多区别,但内存不足时会回收软引用的对象。

    注:当系统内存充足时,系统不会进行软引用的内存回收, 当系统不足时将会回收软引用的对象。
    当用 java -Xmx1m -Xms1m SoftReferenceTest 命令时强制堆内存为1m时 软引用引用对象将被回收。(可以创建10000个对象)

    3.弱引用(weakReference)
    弱引用通过weakReference类来实现
    弱引用具有很强的不确定性。因为垃圾回收每次都会回收弱引用的对象。

    4.虚引用

    • 软引用和弱引用可以单独使用,虚引用不能单独使用,虚引用的作用是就跟踪对象被垃圾回收的状态,程序可以通过检测与虚引用关联的虚引用队列是否已经包含了指定的虚引用,从而了解虚引用的对象是否即将被回收。

    • PhantomReference对象实现

    • 虚引用通过PhantomRefence类实现,它本身对对象没有影响,类似与没有应用,对象甚至感觉不到虚引用的存在,如果一个对象只有一个虚引用存在,那么他就类似没有应用存在。

    • 当程序强制垃圾回收后,只有虚引用引用字符串对象将会被垃圾回收,当被引用的对象被回收后,对应的引用将被添加到关联的引用队列中。

    4.软引用
    如果使用软引用,弱引用,虚引用的引用方式引用对象,垃圾回收就能够随意的释放这些对象,若果希望尽可能减小程序在起声明周期中所占用的内存大小,可以灵活使用这些引用。

    如果使用了这些引用就不能保留这些对象的强引用(强制引用应该置null),否则就浪费了这些类提供的任何好处。
    
    展开全文
  • JAVA一样,ANDROID系统也是由GC来自动回收内存的。android中一个应用的启动,android系统都会为这个应用分配一个dalivk虚拟机,以便这个应用运行在这个独立的虚拟机上,可是一个虚拟机内存大小一般也是限制的(20M...
  • 前言: 万能的程序猿可以指定哪些不是垃圾不能被回收,哪些是普通的垃圾可以晚点回收,哪些是超级垃圾需...注意弱引用、软引用、虚引用和强引用的直接区别就是对象都要被一个Reference类包裹。 举例: SoftReference.
  • Java在jdk1.2推出了软引用、弱引用、虚引用三个概念: #1.强引用: 就是我们平时创建的对象引用。 例如: String string = new String(""); 复制代码 类似于这样的引用是强引用。 强引用是不会被垃圾收集器自动收集...
  • 一般来说,我们创建一个一般的对象,如: ...#垃圾收集器的根节点的引用和强引用的对象包含的引用都是强引用。 在java的源码中,有这么几个类 -java.lang.ref  +SoftReference.java  +WeakReferenc
  • Java对象的引用

    2018-03-15 10:05:16
    被强引用所引用的java对象,绝对不会被垃圾回收机制回收,即使系统内存非常紧张,JVM也不会回收被强引用所引用的Java对象2、软引用SoftReference如果内存足够,软引用和强引用没多大差别,当内存告急时,GC会回收掉...
  • Java的四种引用方式

    2020-03-19 15:08:40
    强引用 是四种引用方式生命周期最长的一个,任何情况下不会被JVM回收,如果JVM内存不足,则会报出OutOfMemory异常,如果想要终止强引用和某个...弱引用和强引用,软引用相比生命周期更短,垃圾回收器一旦发现,就会...
  • Java中的WeakHashMap

    2020-06-13 19:49:24
    Java中的WeakHashMap是中高级Java开发人员中非常流行的数据结构。 WeakHashMap类位于java.util包中。... 在本文中,我们将首先讨论Java中的引用类型-软引用,弱引用和强引用。 然后,我们将了解WeakHashMap ...
  • jvm四种引用

    2019-04-17 21:05:06
    Java中的引用一共有四种,它们分别是强引用、软引用、弱引用和虚引用,下面我们来分别介绍。 1 首先来说说强引用,强引用就是我们平常用的类似于“Object obj = new Object()”的引用,只要obj的生命周期没结束,...
  • 引用活动的四种方式: 强引用 通常不带任何修饰符的引用的就是强引用,垃圾回收器正常下都不会对其进行回收操作,所以当内存空间不足时Java虚拟机会抛出OutOfMemoryError错误使...WeakReference 弱引用 一般和强引...
  • Java中根据垃圾回收的方式不同,引用按照对象生命周期的长短分为四种,由高到低分别为强引用、软引用、弱引用和虚引用。 强引用 Java中默认的引用类型,一个对象如果具有强引用那么就没有资格被垃圾回收。 软引用...
  • 弱引用 虚引用 3.强引用 是指创建一个对象并把这个对象赋给一个引用变量。 强引用有引用变量指向时永远不会被垃圾回收。即使内存不足的时候。 4.软引用 软引用通过SoftReference类来实现 软引用的对象...
  • 16Java数据类型详解

    2020-12-22 15:33:48
    类型语言 和强类型语言相反 Java的数据类型分为两大类 基本类型(primitive type)(常用,剩下的都是引用类型) 用数字表示:整数类型、浮点(小数,4个字符和8个字符的字节范围和整数一样),4个字节表示小一点...
  • 浅谈WeakHashMap

    2018-07-12 13:45:47
    弱引用和强引用Java GC有什么不同影响?本文将给出清晰而简洁的介绍。总体介绍在Java集合框架系列文章的最后,笔者打算介绍一个特殊的成员:WeakHashMap,从名字可以看出它是某种 Map。它的特殊之处在于 ...
  • 有两种:不变模式和强不变模式。  不变模式:该类不变,子类有可能变化。1. 引用到其他对象时,在类内部初始化,如果必须在客户端初始化的,则在类内部使用复制方式进行初始化。  强不变模式: 在满足不变...
  • 什么是WeakHashMap--转

    2019-09-27 03:54:07
    JavaWeakHashMap到底Weak在哪里,它真的很弱吗?...弱引用和强引用Java GC有什么不同影响?本文将给出清晰而简洁的介绍。 总体介绍 在Java集合框架系列文章的最后,笔者打算介绍一个特殊的成员:WeakHashM...
  • 浅谈 WeakHashMap

    2017-02-16 17:38:00
    弱引用和强引用Java GC有什么不同影响?本文将给出清晰而简洁的介绍。 总体介绍 在Java集合框架系列文章的最后,笔者打算介绍一个特殊的成员:WeakHashMap,从名字可以看出它是某种 Map。它的特殊之处在于...
  • WeakHashMap

    2019-03-05 19:15:01
    弱引用和强引用Java GC有什么不同影响? 2.介绍 WeakHashMap,从名字可以看出它是某种 Map。它的特殊之处在于 WeakHashMap 里的entry可能会被GC自动删除,即使程序员没有调用remove()或者clear()方法。 更...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

java弱引用和强引用

java 订阅