softreferenceJAVA的软弱虚引用有什么用，主要在什么时候用？

什么是generic reference?

是语法书上的吧 意思是:类指 --------- 冠词的表意功能可以归纳为二种,即类指(GENERIC REFERENCE〕和特指(SPECIFIC REFERENCE〕。

详细资料参考 /bbs/showbbs.asp?bd=6&id=995&totable=1

JAVA垃圾回收器如何工作

java回收器有gc 以下是工作原理： 强引用（StrongReference） 这个就不多说，我们写代码天天在用的就是强引用。

如果一个对象被被人拥有强引用，那么垃圾回收器绝不会回收它。

当内存空间不足，Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

Java 的对象是位于 heap 中的，heap 中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。

应用的强弱顺序是强、软、弱、和虚。

对于对象是属于哪种可及的对象，由他的最强的引用决定。

如下 代码： String abc=new?String("abc");?//1 SoftReference<String> softRef=new?SoftReference<String>(abc);?//2 WeakReference<String> weakRef =?new?WeakReference<String>(abc);?//3 abc=null;?//4 softRef.clear();//5 第一行在 heap 堆中创建内容为“abc”的对象，并建立 abc 到该对象的强引用，该对象是强可及的。

第二行和第三行分别建立对 heap 中对象的软引用和弱引用，此时 heap 中的 abc 对象已经有 3 个引用，显然此时 abc 对象仍是强可及的。

第四行之后 heap 中对象不再是强可及的，变成软可及的。

第五行执行之后变成弱可及的。

软引用（SoftReference） 如果一个对象只具有软引用，那么如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。

只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存。

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

软引用是主要用于内存敏感的高速缓存。

在 jvm 报告内存不足之前会清除所有的软引用，这样以来 gc 就有可能收集软可及的对象，可能解决内存吃紧问题，避免内存溢出。

什么时候会被收集取决于 gc 的算法和 gc 运行时可用内存的大小。

当 gc 决定要收集软引用时执行以下过程,以上面的 softRef 为例： 1 首先将 softRef 的 referent（abc）设置为 null，不再引用 heap 中的 new String("abc")对象。

2 将 heap 中的 new String("abc")对象设置为可结束的(finalizable)。

3 当 heap 中的 new String("abc")对象的 finalize()方法被运行而且该对象占用的内存被释放， softRef 被添加到它的 ReferenceQueue(如果有的话)中。

注意:对 ReferenceQueue 软引用和弱引用可以有可无，但是虚引用必须有。

被 Soft Reference 指到的对象，即使没有任何 Direct Reference，也不会被清除。

一直要到 JVM 内存 不足且没有 Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之用的。

如此一来 SoftReference 不但可以把对象 cache 起来，也不会造成内存不足的错误 （OutOfMemoryError）。

弱引用（WeakReference） 如果一个对象只具有弱引用， 那该类就是可有可无的对象， 因为只要该对象被 gc 扫描到了随时都会把它干掉。

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。

在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

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

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

虚引用（PhantomReference） "虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。

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

虚引用主要用来跟踪对象被 垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。

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

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。

程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

建立虚引用之后通过 get 方法返回结果始终为 null,通过源代码你会发现,虚引用通向会把引用的对象写进 referent,只是 get 方法返回结果为 null。

先看一下和 gc 交互的过程再说一下他的作用。

1 不把 referent 设置为 null, 直接把 heap 中的 new String("abc")对象设置为可结束的(finalizable)。

2 与软引用和弱引用不同, 先把 PhantomRefrence 对象添加到它的 ReferenceQueue 中.然后在释放虚可及的对象。

谁能解释下JAVA中的强引用、弱引用、软引用、虚引用，尽量通俗点，谢谢！！

1．强引用 本章前文介绍的引用实际上都是强引用，这是使用最普遍的引用。

如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。

当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

2．软引用（SoftReference） 如果一个对象只具有软引用，那就类似于可有可物的生活用品。

如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。

只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存。

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

3．弱引用（WeakReference） 如果一个对象只具有弱引用，那就类似于可有可物的生活用品。

弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。

在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

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

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

4．虚引用（PhantomReference） "虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。

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

虚引用主要用来跟踪对象被垃圾回收的活动。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。

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

程序可以通过判断引用队列中是 否已经加入了虚引用，来了解 被引用的对象是否将要被垃圾回收。

程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

使用LowProfileImageLoader缓存加载图片的时候报内存溢出，怎么解 ？

三种方法解决：

方法一：

在从网络或本地加载图片的时候，只加载缩略图。

/**

1. * 按照路径加载图片
2. * @param path 图片资源的存放路径
3. * @param scalSize 缩小的倍数
4. * @return
5. */
6. publicstaticBitmap loadResBitmap(String path,intscalSize) {
7. BitmapFactory.Options options =newBitmapFactory.Options();
8. options.inJustDecodeBounds =false;
9. options.inSampleSize = scalSize;
10. Bitmap bmp = BitmapFactory.decodeFile(path, options);
11. returnbmp;
12. }

这个方法的确能够少占用不少内存，可是它的致命的缺点就是，因为加载的是缩略图，所以图片失真比较严重，对于对图片质量要求很高的应用，可以采用下面的方法。

方法二：

运用JAVA的软引用，进行图片缓存，将经常需要加载的图片，存放在缓存里，避免反复加载。

关于软引用（SoftReference）的详细说明，请参看/club/clubbbsinfo-9255.html。

下面是我写的一个图片缓存的工具类。

/**

1. *
2. * @author larson.liu
3. * 该类用于图片缓存，防止内存溢出
4. */
5. lassBitmapCache {
6. static*BitmapCache cache;
7. /** 用于Chche内容的存储*/
8. *Hashtable bitmapRefs;
9. /** 垃圾Reference的队列（所引用的对象已经被回收，则将该引用存入队列中）*/
10. *ReferenceQueue q;
12. /**
13. * 继承SoftReference，使得每一个实例都具有可识别的标识。
    
    
14. */
15. *classBtimapRefextendsSoftReference {
16. *Integer _key =0;
18. publicBtimapRef(Bitmap bmp, ReferenceQueue q,intkey) {
19. super(bmp, q);
20. _key = key;
21. }
22. }
24. *BitmapCache() {
25. bitmapRefs =newHashtable();
26. q =newReferenceQueue();
28. }
30. /**
31. * 取得缓存器实例
32. */
33. publicstaticBitmapCache getInstance() {
34. if(cache ==null) {
35. cache =newBitmapCache();
36. }
37. returncache;
39. }
41. /**
42. * 以软引用的方式对一个Bitmap对象的实例进行引用并保存该引用
43. */
44. *voidaddCacheBitmap(Bitmap bmp, Integer key) {
45. cleanCache();// 清除垃圾引用
46. BtimapRef ref =newBtimapRef(bmp, q, key);
47. bitmapRefs.put(key, ref);
48. }
50. /**
51. * 依据所指定的drawable下的图片资源ID号（可以根据自己的需要从网络或本地path下获取），重新获取相应Bitmap对象的实例
52. */
53. publicBitmap getBitmap(intresId, Context context) {
54. Bitmap bmp =null;
55. // 缓存中是否有该Bitmap实例的软引用，如果有，从软引用中取得。
    
    
56. if(bitmapRefs.containsKey(resId)) {
57. BtimapRef ref = (BtimapRef) bitmapRefs.get(resId);
58. bmp = (Bitmap) ref.get();
59. }
60. // 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，
61. // 并保存对这个新建实例的软引用
62. if(bmp ==null) {
63. bmp = BitmapFactory.decodeResource(context.getResources(), resId);
64. this.addCacheBitmap(bmp, resId);
65. }
66. returnbmp;
67. }
69. *voidcleanCache() {
70. BtimapRef ref =null;
71. while((ref = (BtimapRef) q.poll()) !=null) {
72. bitmapRefs.remove(ref._key);
73. }
74. }
76. // 清除Cache内的全部内容
77. publicvoidclearCache() {
78. cleanCache();
79. bitmapRefs.clear();
80. System.gc();
81. System.runFinalization();
82. }
84. }

在程序代码中调用该类：

imageView.setImageBitmap(bmpCache.getBitmap(R.drawable.kind01, this));

这样当你的imageView需要来回变换背景图片时，就不需要再重复加载。

方法三：

及时销毁不再使用的Bitmap对象。

if (bitmap != null && b!itmap.isRecycled()){

bitmap.recycle();

bitmap = null; // recycle()是个比较漫长的过程，设为null，然后在最后调用System.gc()，效果能好很多

}

System.gc();

JAVA的软弱虚引用有什么用，主要在什么时候用？

强引用，任何时候都不会被；垃圾回收器回收，如果内存不足，宁愿抛出OutOfMemoryError 软引用，只有在内存将满的时候才会被垃圾回收器回收，如果还有可用内存，垃圾回收器不会回收 弱引用，只要垃圾回收器运行，就肯定会被回收，不管还有没有可用内存。

虚引用，虚引用等于没有引用，任何时候都有可能被垃圾回收。

---------------- 下面谈谈我的理解： 软引用非常适合用来实现高速缓存。

高速缓存的特点，如果命中则能加快响应，如果未命中还能去重新获取原始数据。

如对某更新频率低，但查询很慢的数据库。

SQL查询高速缓存是个不错的注意。

import?java.lang.ref.SoftReference; import?java.util.HashMap; import?java.util.Map; public?class?Test?{ private?static?Map?sqlCache?=?new?HashMap<>(); private?static?Object?getFromChache(String?sql)?{ SoftReference?sr?=?sqlCache.get(sql); Object?object?=?sr?==?null???null?:?sr.get(); if?(object?==?null)?{ object?=?getFromQuery(sql); sqlCache.put(sql,?new?SoftReference(object)); } return?object; } private?static?Object?getFromQuery(String?sql)?{ ????????//从数据库查询，速度较慢。

return?null; } }? --------------- 为什么不直接使用Map，因为这样的话就会是强引用，随着缓存的越来越多，内存会耗尽，而垃圾回收不会回收，因为数据还被强引用引用。

而是用软引用，会在内存将耗尽的情况下，将其进行垃圾回收（会优先回收最近不被使用的软引用对象）