精华内容
参与话题
问答
  • 弱引用

    2018-08-11 14:00:00
    弱引用 正是因为有引用,对象才会在内存中存在。 当对象的引用数量归零后,垃圾回收程序会把对象销毁。 但是,有时需要引用对象,而不让对象存在的时间超过所需时间。 这经常用在缓存中。 弱引用不会增加对象...

    弱引用

    正是因为有引用,对象才会在内存中存在。
    当对象的引用数量归零后,垃圾回收程序会把对象销毁。
    但是,有时需要引用对象,而不让对象存在的时间超过所需时间。
    这经常用在缓存中。
     
    弱引用不会增加对象的引用数量。
    引用的目标对象称为所指对象(referent)。
    因此我们说,弱引用不会妨碍所指对象被当作垃圾回收。
    弱引用在缓存应用中很有用,因为我们不想仅因为被缓存引用着而始终保存缓存对象。
     
    如果对象存在,调用弱引用可以获取对象;否则返回 None。
    弱引用是可调用的对象,返回的是被引用的对象;如果所指对象不存在了,返回 None。
     

    WeakValueDictionary简介

    WeakValueDictionary 类实现的是一种可变映射,里面的值是对象的弱引用。
    被引用的对象在程序中的其他地方被当作垃圾回收后,对应的键会自动从 WeakValueDictionary 中删除。
    因此,WeakValueDictionary 经常用于缓存。
     
    临时变量引用了对象,这可能会导致该变量的存在时间比预期长。
    通常,这对局部变量来说不是问题,因为它们在函数返回时会被销毁。
    但是全局变量,除非显式删除,否则不会消失。
     
    weakref 模块还提供了 WeakSet 类,按照文档的说明,这个类的作用很简单:“保存元素弱引用的集合类。元素没有强引用时,集合会把它删除。
    ”如果一个类需要知道所有实例,一种好的方案是创建一个WeakSet 类型的类属性,保存实例的引用。
    如果使用常规的 set,实例永远不会被垃圾回收,因为类中有实例的强引用,而类存在的时间与Python 进程一样长,除非显式删除类。
     

    弱引用的局限

    不是每个 Python 对象都可以作为弱引用的目标(或称所指对象)。
    基本的 list 和 dict 实例不能作为所指对象,但是它们的子类可以轻松地解决这个问题:
    class MyList(list):
    """list的子类,实例可以作为弱引用的目标"""
     
    a_list = MyList(range(10))
    # a_list可以作为弱引用的目标
     
    wref_to_a_list = weakref.ref(a_list)
     
    set 实例可以作为所指对象。用户定义的类型也没问题。
    但是,int 和 tuple 实例不能作为弱引用的目标,甚至它们的子类也不行。
     
     
     
     
     
     
     
     

    转载于:https://www.cnblogs.com/nzd123456/p/9459600.html

    展开全文
  • java弱引用

    2018-01-18 18:05:27
    java 弱引用代码以及分析,详细讲解弱引用与强引用在垃圾回收时产生的区别
  • 本文介绍了弱引用是对一个对象的引用的持有者。使用弱引用后,可以维持对referent的引用,而不会阻止它被垃圾收集。当垃圾收集器跟踪堆的时候,如果对一个对象的引用只有弱引用,那么这个referent就会成为垃圾收集的...
  • 强引用,软引用,弱引用,虚引用

    千次阅读 2015-04-21 14:44:38
    强引用,软引用,弱引用,虚引用 强引用: 我们一般使用的就是强引用。垃圾回收器绝不会回收它。 当内存空间不足时Java虚拟机宁愿抛出OutOfMemoryError错误使程序异常终止,也不会回收具有强引用的对象来解决内存不足...


    强引用,软引用,弱引用,虚引用



    强引用:
    我们一般使用的就是强引用。垃圾回收器绝不会回收它。
    当内存空间不足时Java虚拟机宁愿抛出OutOfMemoryError错误使程序异常终止,也不会回收具有强引用的对象来解决内存不足的问题


    软引用:
    如果一个对象具有软引用,那么当内存空间足够的时候GC就不会回收它,如果内存空间不足了,就会回收这些对象的内存空间。


    弱引用:

    如果一个对象具有弱引用,那么当GC线程扫描的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。

    其实准备地说应该是"如果一个对象只具有弱引用.........",即仅有弱引用而不存在对其的强引用才会将其回收.

    但由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。




    为了防止内存溢出,在处理一些占用内存大而且声明周期较长的对象时候,可以尽量应用软引用和弱引用.
    但是也请注意在Android较老版本中,常用软引用或弱引用 (SoftReference or WeakReference)实现内存缓存技术。
    但从 Android 2.3 (API Level 9)开始,GC会更倾向于回收持有软引用或弱引用的对象,这让软引用和弱引用变得不再可靠。


    虚引用:
    顾名思义,“虚引用”就是形同虚设,与其他三种引用都不同它并不会决定对象的生命周期。
    如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。
    虚引用主要用来跟踪对象被垃圾回收器回收的活动。
    展开全文
  • 弱引用和长弱引用

    2014-11-01 19:16:51
    可创建短弱引用或长弱引用: Short 垃圾回收功能回收对象后,短弱引用的目标会变为 null。 弱引用本身是托管对象,和任何其他托管对象一样需要经过垃圾回收。短弱引用是 WeakReference 的默认构造函数。 Long ...
    可创建短弱引用或长弱引用:
    Short
    垃圾回收功能回收对象后,短弱引用的目标会变为 null。 弱引用本身是托管对象,和任何其他托管对象一样需要经过垃圾回收。短弱引用是 WeakReference 的默认构造函数。
    Long
    调用对象的 Finalize 方法后,会保留长弱引用。 这样,您就可以重新创建该对象,但该对象仍保持不可预知的状态。 要使用长引用,请在 WeakReference 构造函数中指定 true。
    如果对象的类型没有 Finalize 方法,则会应用短弱引用功能,该弱引用只在目标被收集之前有效,运行终结器之后可以随时收集目标。
    要建立强引用并重新使用该对象,请将 WeakReference 的 Target 属性强制转换为该对象的类型。 如果 Target 属性返回 null,则表示对象已被收集;否则,您可继续使用该对象,因为应用程序已重新获得了对它的强引用。
    使用弱引用的准则
    仅在必要时使用长弱引用,因为在终止后对象的状态是不可预知的。
    避免对小对象使用弱引用,因为指针本身可能和对象一样大,或者比对象还大。
    不应将弱引用作为内存管理问题的自动解决方案, 而应开发一个有效的缓存策略来处理应用程序的对象。
    展开全文
  • 用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。强引用: Java中的引用,有点像C++的指针。...

    用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。他们代表了JVM回收内存的四种强度,分别如下。

    强引用:

    Java中的引用,有点像C++的指针。通过引用,可以对堆中的对象进行操作。在某函数中,当创建了一个对象,该对象被分配在堆中,通过这个对象的引用才能对这个对象进行操作。

    Object o=new Object();

    假设以上代码是在函数体内运行的,那么局部变量o将被分配在栈上,而对象实例,被分配在堆上。局部变量o指向Object实例所在的堆空间,通过o可以操作该实例,那么o就是Object的引用。


    如果再创建一个赋值语句

    Object oj=o;
    那么o指向的Object内存空间也会被oj所指向,此时我们可以说oj==o,那么ob.equals也肯定相等,即两个对象的值也肯定一样,当修改了o对象的时候,oj对象也会发生变化,或者当修改了oj对象的时候o对象也肯定会变化。所以如果想复制另外一个对象的值的话千万不要用这种方式,在多线程的情况下可能会有更槽糕的情况发生,你可以使用JDK自带的克隆方法,也可以重写克隆方法。

    public class Test1 {
    			public static void main(String[] args) {
    				student S=new student("1","我是大s");
    				student s=S;
    				System.out.println(s==S); //true
    				System.out.println(s.equals(S)); //true
    				System.out.println("打印出大S"+S); //id=1
    				System.out.println("打印出小s"+s); //id=1
    				S.setId("2");
    				System.out.println("修改后的大S"+S);  //id=2
    				System.out.println("未修改后的小s"+s); //id=2
    				s.setId("3");
    				System.out.println("未修改后的大S"+S); //id=3
    				System.out.println("修改后的小s"+s); //id=3
    	
    			}
    }
    class student{
    	String name;
    	String id;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public student(String name, String id) {
    		super();
    		this.name = name;
    		this.id = id;
    	}
    	@Override
    	public String toString() {
    		return "student [name=" + name + ", id=" + id + "]";
    	}
    	
    	
    }




    上例中的大S和小S都是强引用,强引用具有如下特点:

    1.强引用可以直接访问目标对象。

    2.强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常,也不会回收强引用所指向的对象。

    3.强引用可能导致内存泄漏,为了避免内存泄漏,在使用完成之后我们可以把字符串对象设置为null,如果是集合的话可以使用

    List list=new ArrayList<>();
    list.clear();

    软引用:

    软引用的强度是仅次于强引用的,如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。   

    我们可以使用java.lang.ref.SoftReference来创建软引用;

    String str=new String("abc");                                     // 强引用
    SoftReference<String> softRef=new SoftReference<String>(str);     // 软引用
    当内存不足时,等价于:

    If(JVM.内存不足()) {
       str = null;  // 转换为软引用
       System.gc(); // 垃圾回收器进行回收
    }

    弱引用:

    弱引用的强度比软引用更次,也就是说只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。

    如果这个对象是偶尔的使用,并且希望在使用时随时就能获取到,但又不想影响此对象的垃圾收集,那么你应该用 Weak Reference 来标记此对象。

    String str=new String("abc");    
    WeakReference<String> abcWeakRef = new WeakReference<String>(str);
    str=null;
    如果你想把这个对象变成强引用的话可以使用

    String  abc = abcWeakRef.get();

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

    当你想引用一个对象,但是这个对象有自己的生命周期,你不想介入这个对象的生命周期,这时候你就是用弱引用。

    这个引用不会在对象的垃圾回收判断中产生任何附加的影响。

    public class ReferenceTest {
    
    	private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>();
    
    	public static void checkQueue() {
    		Reference<? extends VeryBig> ref = null;
    		while ((ref = rq.poll()) != null) {
    			if (ref != null) {
    				System.out.println("In queue: "	+ ((VeryBigWeakReference) (ref)).id);
    			}
    		}
    	}
    
    	public static void main(String args[]) {
    		int size = 3;
    		LinkedList<WeakReference<VeryBig>> weakList = new LinkedList<WeakReference<VeryBig>>();
    		for (int i = 0; i < size; i++) {
    			weakList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
    			System.out.println("Just created weak: " + weakList.getLast());
    
    		}
    
    		System.gc(); 
    		try { // 下面休息几分钟,让上面的垃圾回收线程运行完成
    			Thread.currentThread().sleep(6000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		checkQueue();
    	}
    }
    
    class VeryBig {
    	public String id;
    	// 占用空间,让线程进行回收
    	byte[] b = new byte[2 * 1024];
    
    	public VeryBig(String id) {
    		this.id = id;
    	}
    
    	protected void finalize() {
    		System.out.println("Finalizing VeryBig " + id);
    	}
    }
    
    class VeryBigWeakReference extends WeakReference<VeryBig> {
    	public String id;
    
    	public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq) {
    		super(big, rq);
    		this.id = big.id;
    	}
    
    	protected void finalize() {
    		System.out.println("Finalizing VeryBigWeakReference " + id);
    	}
    }

    虚引用

    虚引用顾名思义就是形同虚设,虚引用也称为幻影引用:一个对象是都有虚引用的存在都不会对生存时间都构成影响,也无法通过虚引用来获取对一个对象的真实引用。唯一的用处:能在对象被GC时收到系统通知,JAVA中用PhantomReference来实现虚引用。

    对比不同:


    class Grocery {
    		private static final int SIZE = 10000;
    		// 属性d使得每个Grocery对象占用较多内存,有80K左右
    		private double[] d = new double[SIZE];
    		private String id;
    		public Grocery(String id) {
    			this.id = id;
    		}
    		public String toString() {
    			return id;
    		}
    		public void finalize() {
    			System.out.println("即将回收 " + id);
    		}
    	}
    	public class References {
    		private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>();
    		public static void checkQueue() {
    			Reference<? extends Grocery> inq = rq.poll(); // 从队列中取出一个引用
    			if (inq != null)
    				System.out.println("In queue: " + inq + " : " + inq.get());
    		}
    		public static void main(String[] args) {
    			final int size = 10;
    			// 创建10个Grocery对象以及10个软引用
    			Set<SoftReference<Grocery>> sa = new HashSet<SoftReference<Grocery>>();
    			for (int i = 0; i < size; i++) {
    				SoftReference<Grocery> ref = new SoftReference<Grocery>(
    						new Grocery("软引用 " + i), rq);
    				System.out.println("刚刚 创建了: " + ref.get());
    				sa.add(ref);
    			}
    			System.gc();
    			checkQueue();
    			// 创建10个Grocery对象以及10个弱引用
    			Set<WeakReference<Grocery>> wa = new HashSet<WeakReference<Grocery>>();
    			for (int i = 0; i < size; i++) {
    				WeakReference<Grocery> ref = new WeakReference<Grocery>(
    						new Grocery("弱引用 " + i), rq);
    				System.out.println("刚刚 创建了: " + ref.get());
    				wa.add(ref);
    			}
    			System.gc();
    			checkQueue();
    			// 创建10个Grocery对象以及10个虚引用
    			Set<PhantomReference<Grocery>> pa = new HashSet<PhantomReference<Grocery>>();
    			for (int i = 0; i < size; i++) {
    				PhantomReference<Grocery> ref = new PhantomReference<Grocery>(
    						new Grocery("abc " + i), rq);
    				System.out.println("刚刚 创建了: " + ref.get());
    				pa.add(ref);
    			}
    			System.gc();
    			checkQueue();
    		}
    }
    在上面的这个例子中,依次创建了十个10个软引用、10个弱引用和10个虚引用,它们各自引用一个Grocery对象。并且在创建之后调用GC方法。从程序运行时的打印结果可以看出,虚引用形同虚设,它所引用的对象随时可能被垃圾回收,具有弱引用的对象拥有稍微长的生命周期,当垃圾回收器执行回收操作时,有可能被垃圾回收,具有软引用的对象拥有较长的生命周期,但在Java虚拟机认为内存不足的情况下,也会被垃圾回收。

    总结

    强引用:就像是老板(OOM)的亲儿子一样,在公司可以什么事都不干,但是千万不要老是占用公司的资源为他自己做事,记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。
    软引用:有点像老板(OOM)的亲戚,在公司表现不好有可能会被开除,即使你投诉他(调用GC)上班看片,但是只要不被老板看到(被JVM检测到)就不会被开除(被虚拟机回收)。
    弱引用:就是一个普通的员工,平常如果表现不佳会被开除(对象没有其他引用的情况下),遇到别人投诉(调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
    虚引用:这货估计就是个实习生跟临时工把,遇到事情的时候想到了你,没有事情的时候,秒秒钟拿出去顶锅,开除。









    展开全文
  • 在Java中提供了4个级别的引用:强引用,软引用,弱引用,虚引用。在这4个引用级别中,只有强引用FinalReference类是包内可见,其他3中引用类型均为public,可以在应用程序中直接使用。 强引用 Java中的引用,有点像...
  • 引用平时我们编程的时候例如:Object object=new Object();那object就是一个强引用了。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空 间不足,Java虚拟机宁愿抛出...
  • 软引用、弱引用、虚引用 总结

    千次阅读 2013-11-15 20:37:44
    在看‘深入JAVA虚拟机’垃圾收集这一章的时候了解有关对象的引用级别,在网上找了些资料总结备忘。(该文章大多内容为多个网站的内容合并)   1、概述  在JDK1.2以前的版本中,当一个对象不被任何变量引用,...
  • 1.对象的强、软、和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及(reachable)状态,程序才能使用它。从JDK 1.2版本开始,把对象的...
  • 今天学习JAVA四种引用的记录 1. 强引用 (StrongReference) 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出 OutOfMemoryError...
  • Java 强引用,软引用,弱引用

    千次阅读 2014-06-28 14:23:12
    1、强引用 public void handleMessage(Message msg) { case FAIL: GoplayException mException = new GoplayException(); setVideoUrlFailReason(mException); mListener.onFailed(mException); break;
  • 主要介绍了Java中强引用,软引用,弱引用概念解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java从JDK1.2版本开始,就把对象的引用分为四种级别,从而使程序能更加灵活的...这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。本文给大家介绍Android利用软引用和弱引用避免OOM,需要的朋友一起学习吧
  • 很早Java API就添加了弱引用(WeakReference)和软引用(SoftReference),但并不是所有的程序员都熟悉这两个概念
  • Java四种引用包括强引用,软引用,弱引用,虚引用。 Java四种引用包括强引用,软引用,弱引用,虚引用。   强引用: 只要引用存在,垃圾回收器永远不会回收 Object obj = new Object(); //可直接通过...
  • 弱引用和强引用

    2012-12-26 22:07:00
    与之相对应还有一种弱引用(Weak Reference),在处理弱引用时,如果该符号有定义,则链接器将对该符号的引用进行决议,如果该符号未被定义,则链接器对于该引用不报错。 链接器处理强引用和弱引用的过程几乎...
  • 为了解决内存操作不灵活这个问题,可以采用软引用等方法。    在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及状态,程序才能使用它。这 ...
  • 强引用 弱引用

    2014-07-24 13:48:21
    1.对象的强、软、弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用...这4种级别由高到低依次为:强引用、软引用、弱引用和虚引用。图1为对象应用类层次。 图1 ⑴强引用
  • 强引用 弱引用 软引用

    千次阅读 2014-03-12 15:42:19
    Java之WeakReference与SoftReference使用讲解 ...Java 2 平台引入了 java.lang.ref 包,其中包括的类可以让您引用对象,而不将它们留在内存中。这些类还提供了与垃圾收集器(garbage collector)之间有限的交互。
  • 强引用弱引用软引用

    2014-09-22 21:10:34
     在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及状态,程序才能使用它。这 就像在日常生活中,从商店购买了某样物品后,如果有用,就一直保留它...
  • 1、软引用(SoftReference) 如果一个对象只具有软引用,那就类似于可有可物的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存空间不足了,就会回收这些对象的内存。只 要垃圾回收器没有回收它,该...
  • 转载请注明出处:... 1、强引用(StrongReference) ... 强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。如下: [java] view plaincopyprint?
  • 1.概念解释强引用是使用最普遍的引用:Object o=new Object(); 特点:不会被GC将对象的引用显示地置为null:o=null; // 帮助垃圾收集器回收此对象举例ArrayList的实现源代码: 软引用用来描述一些还有用但是并非...

空空如也

1 2 3 4 5 ... 20
收藏数 9,538
精华内容 3,815
关键字:

弱引用