Android防止内存溢出浅析/应用自动更新功能的代码实现

来源：互联网发布：用java写一个登陆界面编辑：程序博客网时间：2024/05/01 11:00

作者：力华

Android的虚拟机是基于寄存器的Dalvik，它的最大堆大小一般是16M。但是Android采用的是Java语言编写，所以在很大程度上，Android的内存机制等同于Java的内存机制，在刚开始开发的时候，内存的限制问题会给我们带来内存溢出等严重问题。在我们不使用一些内存的时候，我们要尽量在Android或者其他平台上避免在运行其他程序时，保存必要的状态，使得一些死进程所带来的内存问题，应该尽量在关闭程序或者保存状态的时候释放掉，这样能提高系统在运行方面的流畅性。

Android的内存主要表现在：

1. 在Android平台上，长期保持一些资源的引用，造成一些内存不能释放，带来的内存泄露问题很多。比如：Context（下文中提到的Activity都是Context），在一些你需要保持你的首个类对象状态，并且把状态传入其他类对象中时，这样消除掉首个类对象之前，你必须先把接收类对象释放掉。需要注意一点的是：因为在Java或者Android内存机制中，顶点的结点释放前必须保证其他对象没有调用才能被系统GC回收释放。我们来看一段代码：

[java] view plaincopy
@Override  
protected void onCreate(Bundle state) {  
     super.onCreate(state);  
     TextViewlabel = new TextView(this);  
     label.setText("Leaksare bad");  
     setContentView(label);  
}  

这个代码的意思就是我们把一个TextView的实例加载到了我们正在运行的Activity（Context）当中，因此，通过GC回收机制，我们知道，要释放Context，就必须先释放掉引用他的一些对象。如果没有，那在要释放Context的时候，你会发现会有大量的内存溢出。所以在你不小心的情况下内存溢出是一件非常容易的事情。保存一些对象时，同时也会造成内存泄露。最简单的比如说位图（Bitmap），比如说：在屏幕旋转时，会破坏当前保持的一个Activity状态，并且重新申请生成新的Activity，直到新的Activity状态被保存。我们再看一段代码：

[java] view plaincopy
privatestatic Drawable sBackground;  
@Override  
protected void onCreate(Bundle state) {  
super.onCreate(state);  
TextView label = new TextView(this);  
label.setText("Leaks are bad");  
  
if (sBackground == null) {  
     sBackground =getDrawable(R.drawable.large_bitmap);  
}  
label.setBackgroundDrawable(sBackground);  
setContentView(label);  
}  

这个代码是非常快的同时也是错误的。它的内存泄露很容易出在屏幕转移的方向上。虽然我们会发现没有显示的保存Context这个实例，但是当我们把绘制的图连接到一个视图的时候，Drawable就会将被View设置为回调，这就说明，在上述的代码中，其实在绘制TextView到活动中的时候，我们已经引用到了这个Activity。链接情况可以表现为：Drawable->TextView->Context。

所以在想要释放Context的时候，其实还是保存在内存中，并没有得到释放。

如何避免这种情况：主要在于。线程最容易出错。大家不要小看线程，在Android里面线程最容易造成内存泄露。线程产生内存泄露的主要原因在于线程生命周期的不可控。下面有一段代码：

[java] view plaincopy
publicclass MyTest extends Activity {  
    @Override  
    publicvoid onCreate(BundlesavedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        new MyThread().start();  
    }  
   
    privateclass MyThread extends Thread{  
        @Override  
        public void run() {  
            super.run();  
            //do somthing  
        }  
    }  
}  

代码很简单，但是在Android上又来新问题了，当我们在切换视图屏幕的时候（横竖屏），就会重新建立横屏或者竖屏的Activity。我们形象的认为之前建立的Activity会被回收，但是事实如何呢？Java机制不会给你同样的感受，在我们释放Activity之前，因为run函数没有结束，这样MyThread并没有销毁，因此引用它的Activity（Mytest）也有没有被销毁，因此也带来的内存泄露问题。

有些人喜欢用Android提供的AsyncTask，但事实上AsyncTask的问题更加严重，Thread只有在run函数不结束时才出现这种内存泄露问题，然而AsyncTask内部的实现机制是运用了ThreadPoolExcutor,该类产生的Thread对象的生命周期是不确定的，是应用程序无法控制的，因此如果AsyncTask作为Activity的内部类，就更容易出现内存泄露的问题。

线程问题的改进方式主要有：

l 将线程的内部类，改为静态内部类。

l 在程序中尽量采用弱引用保存Context。

2. 万恶的bitmap。。。

Bitmap是一个很万恶的对象，对于一个内存对象，如果该对象所占内存过大，在超出了系统的内存限制时候，内存泄露问题就很明显了。。

解决bitmap主要是要解决在内存尽量不保存它或者使得采样率变小。在很多场合下，因为我们的图片像素很高，而对于手机屏幕尺寸来说我们并不用那么高像素比例的图片来加载时，我们就可以先把图片的采样率降低在做原来的UI操作。

如果在我们不需要保存bitmap对象的引用时候，我们还可以用软引用来做替换。具体的实例代码google上面也有很多。

综上所述，要避免内存泄露，主要要遵循以下几点：

第一：不要为Context长期保存引用（要引用Context就要使得引用对象和它本身的生命周期保持一致）。

第二：如果要使用到Context，尽量使用ApplicationContext去代替Context，因为ApplicationContext的生命周期较长，引用情况下不会造成内存泄露问题

第三：在你不控制对象的生命周期的情况下避免在你的Activity中使用static变量。尽量使用WeakReference去代替一个static。

第四：垃圾回收器并不保证能准确回收内存，这样在使用自己需要的内容时，主要生命周期和及时释放掉不需要的对象。尽量在Activity的生命周期结束时，在onDestroy中把我们做引用的其他对象做释放，比如：cursor.close()。

其实我们可以在很多方面使用更少的代码去完成程序。比如：我们可以多的使用9patch图片等。有很多细节地方都可以值得我们去发现、挖掘更多的内存问题。我们要是能做到C/C++对于程序的“谁创建，谁释放”原则，那我们对于内存的把握，并不比Java或Android本身的GC机制差，而且更好的控制内存，能使我们的手机运行得更流畅。

----------------------------------------------------------------------------------------------------

由于Android项目开源所致，市面上出现了N多安卓软件市场。为了让我们开发的软件有更多的用户使用，我们需要向N多市场发布，软件升级后，我们也必须到安卓市场上进行更新，给我们增加了工作量。因此我们有必要给我们的Android应用增加自动更新的功能。

既然实现自动更新，我们首先必须让我们的应用知道是否存在新版本的软件，因此我们可以在自己的网站上放置配置文件，存放软件的版本信息：

[html] view plaincopy
<update>  
    <version>2</version>  
    <name>baidu_xinwen_1.1.0</name>  
    <url>http://gdown.baidu.com/data/wisegame/f98d235e39e29031/baiduxinwen.apk</url>  
</update>  

在这里我使用的是XML文件，方便读取。由于XML文件内容比较少，因此可通过DOM方式进行文件的解析：

[java] view plaincopy
public class ParseXmlService  
{  
    public HashMap<String, String> parseXml(InputStream inStream) throws Exception  
    {  
        HashMap<String, String> hashMap = new HashMap<String, String>();  
          
        // 实例化一个文档构建器工厂  
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
        // 通过文档构建器工厂获取一个文档构建器  
        DocumentBuilder builder = factory.newDocumentBuilder();  
        // 通过文档通过文档构建器构建一个文档实例  
        Document document = builder.parse(inStream);  
        //获取XML文件根节点  
        Element root = document.getDocumentElement();  
        //获得所有子节点  
        NodeList childNodes = root.getChildNodes();  
        for (int j = 0; j < childNodes.getLength(); j++)  
        {  
            //遍历子节点  
            Node childNode = (Node) childNodes.item(j);  
            if (childNode.getNodeType() == Node.ELEMENT_NODE)  
            {  
                Element childElement = (Element) childNode;  
                //版本号  
                if ("version".equals(childElement.getNodeName()))  
                {  
                    hashMap.put("version",childElement.getFirstChild().getNodeValue());  
                }  
                //软件名称  
                else if (("name".equals(childElement.getNodeName())))  
                {  
                    hashMap.put("name",childElement.getFirstChild().getNodeValue());  
                }  
                //下载地址  
                else if (("url".equals(childElement.getNodeName())))  
                {  
                    hashMap.put("url",childElement.getFirstChild().getNodeValue());  
                }  
            }  
        }  
        return hashMap;  
    }  
}  

通过parseXml()方法，我们可以获取服务器上应用的版本、文件名以及下载地址。紧接着我们就需要获取到我们手机上应用的版本信息：

[java] view plaincopy
/** 
 * 获取软件版本号 
 *  
 * @param context 
 * @return 
 */  
private int getVersionCode(Context context)  
{  
    int versionCode = 0;  
    try  
    {  
        // 获取软件版本号，  
        versionCode = context.getPackageManager().getPackageInfo("com.szy.update", 0).versionCode;  
    } catch (NameNotFoundException e)  
    {  
        e.printStackTrace();  
    }  
    return versionCode;  
}  

通过该方法我们获取到的versionCode对应AndroidManifest.xml下android:versionCode。android:versionCode和android:versionName两个属性分别表示版本号，版本名称。versionCode是整数型，而versionName是字符串。由于versionName是给用户看的，不太容易比较大小，升级检查时，就可以检查versionCode。把获取到的手机上应用版本与服务器端的版本进行比较，应用就可以判断处是否需要更新软件。

处理流程

处理代码

[java] view plaincopy
package com.szy.update;  
  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.net.HttpURLConnection;  
import java.net.MalformedURLException;  
import java.net.URL;  
import java.util.HashMap;  
  
import android.app.AlertDialog;  
import android.app.Dialog;  
import android.app.AlertDialog.Builder;  
import android.content.Context;  
import android.content.DialogInterface;  
import android.content.Intent;  
import android.content.DialogInterface.OnClickListener;  
import android.content.pm.PackageManager.NameNotFoundException;  
import android.net.Uri;  
import android.os.Environment;  
import android.os.Handler;  
import android.os.Message;  
import android.view.LayoutInflater;  
import android.view.View;  
import android.widget.ProgressBar;  
import android.widget.Toast;  
  
/** 
 *@author coolszy 
 *@date 2012-4-26 
 *@blog http://blog.92coding.com 
 */  
  
public class UpdateManager  
{  
    /* 下载中 */  
    private static final int DOWNLOAD = 1;  
    /* 下载结束 */  
    private static final int DOWNLOAD_FINISH = 2;  
    /* 保存解析的XML信息 */  
    HashMap<String, String> mHashMap;  
    /* 下载保存路径 */  
    private String mSavePath;  
    /* 记录进度条数量 */  
    private int progress;  
    /* 是否取消更新 */  
    private boolean cancelUpdate = false;  
  
    private Context mContext;  
    /* 更新进度条 */  
    private ProgressBar mProgress;  
    private Dialog mDownloadDialog;  
  
    private Handler mHandler = new Handler()  
    {  
        public void handleMessage(Message msg)  
        {  
            switch (msg.what)  
            {  
            // 正在下载  
            case DOWNLOAD:  
                // 设置进度条位置  
                mProgress.setProgress(progress);  
                break;  
            case DOWNLOAD_FINISH:  
                // 安装文件  
                installApk();  
                break;  
            default:  
                break;  
            }  
        };  
    };  
  
    public UpdateManager(Context context)  
    {  
        this.mContext = context;  
    }  
  
    /** 
     * 检测软件更新 
     */  
    public void checkUpdate()  
    {  
        if (isUpdate())  
        {  
            // 显示提示对话框  
            showNoticeDialog();  
        } else  
        {  
            Toast.makeText(mContext, R.string.soft_update_no, Toast.LENGTH_LONG).show();  
        }  
    }  
  
    /** 
     * 检查软件是否有更新版本 
     *  
     * @return 
     */  
    private boolean isUpdate()  
    {  
        // 获取当前软件版本  
        int versionCode = getVersionCode(mContext);  
        // 把version.xml放到网络上，然后获取文件信息  
        InputStream inStream = ParseXmlService.class.getClassLoader().getResourceAsStream("version.xml");  
        // 解析XML文件。 由于XML文件比较小，因此使用DOM方式进行解析  
        ParseXmlService service = new ParseXmlService();  
        try  
        {  
            mHashMap = service.parseXml(inStream);  
        } catch (Exception e)  
        {  
            e.printStackTrace();  
        }  
        if (null != mHashMap)  
        {  
            int serviceCode = Integer.valueOf(mHashMap.get("version"));  
            // 版本判断  
            if (serviceCode > versionCode)  
            {  
                return true;  
            }  
        }  
        return false;  
    }  
  
/** 
 * 获取软件版本号 
 *  
 * @param context 
 * @return 
 */  
private int getVersionCode(Context context)  
{  
    int versionCode = 0;  
    try  
    {  
        // 获取软件版本号，对应AndroidManifest.xml下android:versionCode  
        versionCode = context.getPackageManager().getPackageInfo("com.szy.update", 0).versionCode;  
    } catch (NameNotFoundException e)  
    {  
        e.printStackTrace();  
    }  
    return versionCode;  
}  
  
    /** 
     * 显示软件更新对话框 
     */  
    private void showNoticeDialog()  
    {  
        // 构造对话框  
        AlertDialog.Builder builder = new Builder(mContext);  
        builder.setTitle(R.string.soft_update_title);  
        builder.setMessage(R.string.soft_update_info);  
        // 更新  
        builder.setPositiveButton(R.string.soft_update_updatebtn, new OnClickListener()  
        {  
            @Override  
            public void onClick(DialogInterface dialog, int which)  
            {  
                dialog.dismiss();  
                // 显示下载对话框  
                showDownloadDialog();  
            }  
        });  
        // 稍后更新  
        builder.setNegativeButton(R.string.soft_update_later, new OnClickListener()  
        {  
            @Override  
            public void onClick(DialogInterface dialog, int which)  
            {  
                dialog.dismiss();  
            }  
        });  
        Dialog noticeDialog = builder.create();  
        noticeDialog.show();  
    }  
  
    /** 
     * 显示软件下载对话框 
     */  
    private void showDownloadDialog()  
    {  
        // 构造软件下载对话框  
        AlertDialog.Builder builder = new Builder(mContext);  
        builder.setTitle(R.string.soft_updating);  
        // 给下载对话框增加进度条  
        final LayoutInflater inflater = LayoutInflater.from(mContext);  
        View v = inflater.inflate(R.layout.softupdate_progress, null);  
        mProgress = (ProgressBar) v.findViewById(R.id.update_progress);  
        builder.setView(v);  
        // 取消更新  
        builder.setNegativeButton(R.string.soft_update_cancel, new OnClickListener()  
        {  
            @Override  
            public void onClick(DialogInterface dialog, int which)  
            {  
                dialog.dismiss();  
                // 设置取消状态  
                cancelUpdate = true;  
            }  
        });  
        mDownloadDialog = builder.create();  
        mDownloadDialog.show();  
        // 现在文件  
        downloadApk();  
    }  
  
    /** 
     * 下载apk文件 
     */  
    private void downloadApk()  
    {  
        // 启动新线程下载软件  
        new downloadApkThread().start();  
    }  
  
    /** 
     * 下载文件线程 
     *  
     * @author coolszy 
     *@date 2012-4-26 
     *@blog http://blog.92coding.com 
     */  
    private class downloadApkThread extends Thread  
    {  
        @Override  
        public void run()  
        {  
            try  
            {  
                // 判断SD卡是否存在，并且是否具有读写权限  
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))  
                {  
                    // 获得存储卡的路径  
                    String sdpath = Environment.getExternalStorageDirectory() + "/";  
                    mSavePath = sdpath + "download";  
                    URL url = new URL(mHashMap.get("url"));  
                    // 创建连接  
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
                    conn.connect();  
                    // 获取文件大小  
                    int length = conn.getContentLength();  
                    // 创建输入流  
                    InputStream is = conn.getInputStream();  
  
                    File file = new File(mSavePath);  
                    // 判断文件目录是否存在  
                    if (!file.exists())  
                    {  
                        file.mkdir();  
                    }  
                    File apkFile = new File(mSavePath, mHashMap.get("name"));  
                    FileOutputStream fos = new FileOutputStream(apkFile);  
                    int count = 0;  
                    // 缓存  
                    byte buf[] = new byte[1024];  
                    // 写入到文件中  
                    do  
                    {  
                        int numread = is.read(buf);  
                        count += numread;  
                        // 计算进度条位置  
                        progress = (int) (((float) count / length) * 100);  
                        // 更新进度  
                        mHandler.sendEmptyMessage(DOWNLOAD);  
                        if (numread <= 0)  
                        {  
                            // 下载完成  
                            mHandler.sendEmptyMessage(DOWNLOAD_FINISH);  
                            break;  
                        }  
                        // 写入文件  
                        fos.write(buf, 0, numread);  
                    } while (!cancelUpdate);// 点击取消就停止下载.  
                    fos.close();  
                    is.close();  
                }  
            } catch (MalformedURLException e)  
            {  
                e.printStackTrace();  
            } catch (IOException e)  
            {  
                e.printStackTrace();  
            }  
            // 取消下载对话框显示  
            mDownloadDialog.dismiss();  
        }  
    };  
  
    /** 
     * 安装APK文件 
     */  
    private void installApk()  
    {  
        File apkfile = new File(mSavePath, mHashMap.get("name"));  
        if (!apkfile.exists())  
        {  
            return;  
        }  
        // 通过Intent安装APK文件  
        Intent i = new Intent(Intent.ACTION_VIEW);  
        i.setDataAndType(Uri.parse("file://" + apkfile.toString()), "application/vnd.android.package-archive");  
        mContext.startActivity(i);  
    }  
}  

效果图

检查模拟器SDCARD是否存在下载文件：

参考代码下载：

http://download.csdn.net/detail/coolszy/4262247

REFERENCES:http://blog.csdn.net/pku_android/article/details/7522440
http://blog.csdn.net/coolszy/article/details/7518345