java弱引用（WeakReference）和SoftReference的区别

weakReference一般用防止内存泄漏，要保证内存被VM回收 

softReference的话，好像多用作来实现cache机制.

 

WeakReference： 

弱引用对象，它们并不禁止其指示对象变得可终结，并被终结，然后被回收。弱引用最常用于实现规范化的映射。  

假定垃圾回收器确定在某一时间点上某个对象是弱可到达对象。这时，它将自动清除针对此对象的所有弱引用，以及通过强引用链和软引用，可以从其到达该对象的针对任何其他弱可到达对象的所有弱引用。同时它将声明所有以前的弱可到达对象为可终结的。在同一时间或晚些时候，它将那些已经向引用队列注册的新清除的弱引用加入队列。   


/////////////////// 
SoftReference： 
软引用对象，在响应内存需要时，由垃圾回收器决定是否清除此对象。软引用对象最常用于实现内存敏感的缓存。  

假定垃圾回收器确定在某一时间点某个对象是软可到达对象。这时，它可以选择自动清除针对该对象的所有软引用，以及通过强引用链，从其可以到达该对象的针对任何其他软可到达对象的所有软引用。在同一时间或晚些时候，它会将那些已经向引用队列注册的新清除的软引用加入队列。   

软可到达对象的所有软引用都要保证在虚拟机抛出   OutOfMemoryError   之前已经被清除。否则，清除软引用的时间或者清除不同对象的一组此类引用的顺序将不受任何约束。然而，虚拟机实现不鼓励清除最近访问或使用过的软引用。   

此类的直接实例可用于实现简单缓存；该类或其派生的子类还可用于更大型的数据结构，以实现更复杂的缓存。只要软引用的指示对象是强可到达对象，即正在实际使用的对象，就不会清除软引用。例如，通过保持最近使用的项的强指示对象，并由垃圾回收器决定是否放弃剩余的项，复杂的缓存可以防止放弃最近使用的项 

 

 

 

Java内存管理之软引用(Soft Reference)

 

软引用(Soft  Reference)的主要特点是具有较强的引用功能。只有当内存不够的时候才回收这类内存，因此在内存足够的时候，他们通常不被回收。另外，这些引用对象还能保证在Java  抛出OutOfMemory异常之前，被设置为null。他可以用于实现一些常用资源的缓存，实现Cache的功能，保证最大限度的使用内存而不引起OutOfMemory异常。

     下面是软引用的实现代码：

 

 

Java代码  

1. import java.lang.ref.SoftReference;  
2. public class softReference {  
3.     public static void main(String[] args) {  
4.         A a = new A();  
5.         // 使用a  
6.         a.test();  
7.         // 使用完了a,将它设置为soft引用类型,并且释放强引用  
8.         SoftReference sr = new SoftReference(a);  
9.         a = null;  
10.         // 下次使用  
11.         if (sr != null) {  
12.             a = (A) sr.get();  
13.             a.test();  
14.         } else {  
15.             // GC由于低内存,已释放a,因此需要重新装载  
16.             a = new A();  
17.             a.test();  
18.             a = null;  
19.             sr = new SoftReference(a);  
20.         }  
21.     }  
22. }  
23. class A {  
24.     public void test() {  
25.         System.out.println("Soft Reference test");  
26.     }  
27. }  

 

 

  软引用技术的引进使Java应用可以更好的管理内存，稳定系统，防止系统内存溢出，避免系统崩溃。因此在处理一些占用内存大而且声明周期较长，但使用并不频繁的对象时应尽量应用该技术。但事物总带有两面性的，有利也有弊，在某些时候对软引用的使用会降低应用的运行效率与性能，例如：应用软引用的对象的初始化过程较为耗时，或者对象的状态在程序的运行过程中发生了变化，都会给重新创建对象与初始化对象带来不同程度的麻烦，有些时候我们要权衡利弊择时应用。

 

 

 

在android中可以巧妙的运用软引用（SoftRefrence）(来源段落：http://winuxxan.blog.51cto.com/2779763/512180)

有些时候，我们使用Bitmap后没有保留对它的引用，因此就无法调用Recycle函数。这时候巧妙的运用软引用，可以使Bitmap在内存快不足时得到有效的释放。如下例：

 

 

Java代码  

1. private class MyAdapter extends BaseAdapter {    
2.   
3. private ArrayList<SoftReference<Bitmap>> mBitmapRefs = new ArrayList<SoftReference<Bitmap>>();    
4. private ArrayList<Value> mValues;    
5. private Context mContext;    
6. private LayoutInflater mInflater;    
7.   
8. MyAdapter(Context context, ArrayList<Value> values) {    
9.     mContext = context;    
10.     mValues = values;    
11.     mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);    
12. }    
13. public int getCount() {    
14.     return mValues.size();    
15. }    
16.   
17. public Object getItem(int i) {    
18.     return mValues.get(i);    
19. }    
20.   
21. public long getItemId(int i) {    
22.     return i;    
23. }    
24.   
25. public View getView(int i, View view, ViewGroup viewGroup) {    
26.     View newView = null;    
27.     if(view != null) {    
28.         newView = view;    
29.     } else {    
30.         newView =(View)mInflater.inflate(R.layout.image_view, false);    
31.     }    
32.   
33.     Bitmap bitmap = BitmapFactory.decodeFile(mValues.get(i).fileName);    
34.     mBitmapRefs.add(new SoftReference<Bitmap>(bitmap));     //此处加入ArrayList    
35.     ((ImageView)newView).setImageBitmap(bitmap);    
36.   
37.     return newView;    
38. }    
39. }