Android开发之内存优化探讨（3）软引用与弱引用的使用

在Android开发中，软引用和弱引用可能用的比较少，但是如果能够在适当的场景下正确的使用，可以对我们的app提供很好的优化体验。

1.强引用：也就是我们最常使用的引用，比如普通声明一个变量

String str = null;
这个str就是强引用。

关于强引用，也就是说，当系统内存不足时，系统宁愿抛出oom异常终止程序，也不会去回收它。

2.软引用：

SoftReference reference = new SoftReference(t);

这里的reference 就是一个指向类T的对象t的软引用；
关于软引用，如果某个对象只被软引用引用，当系统内存不足的时候，如果扫描到它，则会将其回收。如果系统内存充足，则不会回收它。

3.弱引用：

WeakReference<T> weakReference = new WeakReference<T>(t);

这里的weakReference 就是一个指向类T的对象t的弱引用，如果某个对象只被弱引用引用，弱引用的优先级比软引用还要低，即不论内存是否充足，当GC扫描到它的时候就会回收。

4.虚引用：这个引用跟没有引用是一样的，Android中现在已经废弃掉了，一般不怎么会用到，所以这里就不讲了。

下面先举个软引用使用的例子，我目前用到的一个地方就是在aciticy的管理类当中。

这是我实际项目中自己写的一个activity管理类

package com.mnsn.lldr.utils;

import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;

public class MyActivityManger {
    private static MyActivityManger instance;
    private List<SoftReference<Activity>> activityList = Collections.synchronizedList(new LinkedList<SoftReference<Activity>>());

    public void destoryActivty(Activity mactivity) {
        for (int i = 0; i < activityList.size(); i++) {
            Activity activity = activityList.get(i).get();
            if (activity == null || mactivity.equals(activity)) {
                activityList.remove(i);
                i--;
            }
        }

    }

    public static MyActivityManger getInstance() {
        if (instance == null) {
            instance = new MyActivityManger();
        }
        return instance;
    }

    private void destoryActivty(String activityName) {
        for (int i = 0; i < activityList.size(); i++) {
            Activity activity = activityList.get(i).get();
            if (activity != null && activityName.equals(activity.getClass().getSimpleName())) {
                activity.finish();
                activityList.remove(i);
                i--;
            } else if (activity == null) {
                activityList.remove(i);
                i--;
            }

        }
    }

    public void closeActivity(String... names) {
        for (int i = 0; i < names.length; i++) {
            destoryActivty(names[i]);
        }
    }

    /**
     * 添加Activity到集合中
     * 
     * @param activity
     */
    public void addActivity(Activity activity) {
        SoftReference<Activity> reference = new SoftReference<Activity>(activity);
        activityList.add(reference);

    }

    public void exitAll() {

        for (int i = 0; i < activityList.size(); i++) {
            Activity activity = activityList.get(i).get();
            if (activity != null) {
                activity.finish();
            }
            activityList.remove(i);
            i--;
        }

    }

    public void exitAll(Activity mActivity) {

        for (int i = 0; i < activityList.size(); i++) {
            Activity activity = activityList.get(i).get();
            if (activity != null && !mActivity.equals(activity)) {
                activity.finish();
                activityList.remove(i);
                i--;
            } else if (activity == null) {
                activityList.remove(i);
                i--;
            }
        }

    }

    public static void turnToActivity(Context context, Class<?> dest) {
        Intent intent = new Intent(context, dest);
        context.startActivity(intent);
    }

}

我会将项目中所有的activity都添加到这个类中，便于管理，如果是在activity未被主动销毁的情况下，如果内存不足，希望它被回收掉，所以用软引用非常合适。

接下来 再举一个弱引用使用的例子：

package com.example.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;

public class SoftandWeakActivity extends Activity{


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread.start();
    }

    private void UpdateUi(){

    };

    private Handler handler = new Handler(){
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
            case 100:
                UpdateUi();
                break;

            default:
                break;
            }
        };
    };


    private void doSomethingLongTime(){

    }

    Thread thread = new Thread(){
        public void run() {
            doSomethingLongTime();
            handler.sendEmptyMessage(100);
        };
    };
}

当我们使用handler加thread去更新UI的时候，通常会像上面这样写，但是这样写有个问题，可能会照成内存泄露，因为子在hanler和thread的内部，是默认持有当前activity的对象的，如果doSomethingLongTime()这方法执行的时间比较长，当activity已经结束掉了还没执行完，那么此时activity将不会被回收。
我们所希望的当然是，aciticy被结束掉过后，UI当然就不用更新了，aciticy也可及时被回收掉。

那么可以改成以下这样：

package com.example.test;

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;

public class SoftandWeakActivity extends Activity{
    private boolean isonDestroyed;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        thread.start();
    }

    private MyHandler handler = new MyHandler(new WeakReference<Activity>(this));
    public void UpdateUi(){

    };

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
        isonDestroyed = true;

    }

    static class MyHandler extends Handler{


        private WeakReference<Activity> weakReference;
        public MyHandler (WeakReference<Activity> weakReference){
            this.weakReference = weakReference;
        }
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
            case 100:
                SoftandWeakActivity activity = (SoftandWeakActivity)weakReference.get();
                if(activity!=null&&!activity.isonDestroyed){
                    activity.UpdateUi();
                }
                break;

            default:
                break;
            }
        };
    };


    private void doSomethingLongTime(){

    }

    Thread thread = new Thread(){
        public void run() {
            doSomethingLongTime();
            handler.sendEmptyMessage(100);
        };
    };
}

关于弱引用还有一个相当经典的例子，就是我们在应用中用的最广泛的图片处理框架imageloader，

/*******************************************************************************
 * Copyright 2011-2013 Sergey Tarasevich
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package com.nostra13.universalimageloader.cache.memory.impl;

import android.graphics.Bitmap;
import com.nostra13.universalimageloader.cache.memory.BaseMemoryCache;

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;

/**
 * Memory cache with {@linkplain WeakReference weak references} to {@linkplain android.graphics.Bitmap bitmaps}<br />
 * <br />
 * <b>NOTE:</b> This cache uses only weak references for stored Bitmaps.
 *
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
 * @since 1.5.3
 */
public class WeakMemoryCache extends BaseMemoryCache {
    @Override
    protected Reference<Bitmap> createReference(Bitmap value) {
        return new WeakReference<Bitmap>(value);
    }
}

我们可以看到，作者在处理图片缓存的时候，也是用了弱引用。
感兴趣的同学可以去看下imageloader的源码。