Android内存优化大全(二)

*Android内存泄露*
虽然JAVA有垃圾回收机制，但也存在内存泄露。如果我们一个程序中，已经不再使用某个对象，但是因为仍然有引用指向它，垃圾回收器就无法回收它，当然该对象占用的内存就无法被使用，这就造成了内存泄露。如果我们的java运行很久,而这种内存泄露不断的发生，最后就没内存可用了。当然java的，内存泄漏和C/C++是不一样的。如果java程序完全结束后，它所有的对象就都不可达了，系统就可以对他们进行垃圾回收，它的内存泄露仅仅限于它本身，而不会影响整个系统的。C/C++的内存泄露就比较糟糕了，它的内存泄露是系统级，即使该C/C++程序退出，它的泄露的内存也无法被系统回收，永远不可用了，除非重启机器。
Android的一个应用程序的内存泄露对别的应用程序影响不大。为了能够使得Android应用程序安全且快速的运行，Android的每个应用程序都会使用一个专有的Dalvik虚拟机实例来运行，它是由Zygote服务进程孵化出来的，也就是说每个应用程序都是在属于自己的进程中运行的。Android为不同类型的进程分配了不同的内存使用上限，如果程序在运行过程中出现了内存泄漏的而造成应用进程使用的内存超过了这个上限，则会被系统视为内存泄漏，从而被kill掉，这使得仅仅自己的进程被kill掉，而不会影响其他进程（如果是system_process等系统进程出问题的话，则会引起系统重启），这是，我们的应用程序就会崩溃，我们就会看到OOM。
一般而言，android中常见的原因主要有以下几个：
1.数据库的cursor没有关闭。
2.构造adapter没有使用缓存contentview。
3.调用registerReceiver()后未调用unregisterReceiver().
4.未关闭InputStream/OutputStream。
5.Bitmap使用后未调用recycle()。
6.Context泄漏。
7.static关键字等。
下面我们就来逐一说明这些吧：
*1、首先，我们先来说明static，这个是万恶之源*
static是Java中的一个关键字，当用它来修饰成员变量时，那么该变量就属于该类，而不是该类的实例。 不少程序员喜欢用static这个关键字修饰变量，因为他使得变量的生命周期大大延长啦，并且访问的时候，也极其的方便，用类名就能直接访问，各个资源间传值也极其的方便，所以，它经常被我们使用。但如果用它来引用一些资源耗费过多的实例（Context的情况最多），这时就要谨慎对待了。

[java]  view plain copy

1. public class ClassName {     
2.      private static Context mContext;     
3.      //省略     
4.      

以上的代码是很危险的，如果将Activity赋值到么mContext的话。那么即使该Activity已经onDestroy，但是由于仍有对象保存它的引用，因此该Activity依然不会被释放，并且，如果该activity里面再持有一些资源，那就糟糕了。
上面是直接的引用泄露，我们再看google文档中的一个例子。 

[java]  view plain copy

1. private static Drawable sBackground;     
2.   
3.   
4.  @Override     
5.  protected void onCreate(Bundle state) {     
6.    super.onCreate(state);     
7.   
8.   
9.    TextView label = new TextView(this);     
10.    label.setText("Leaks are bad");     
11.   
12.   
13.    if (sBackground == null) {     
14.      sBackground = getDrawable(R.drawable.large_bitmap);     
15.    }     
16.    label.setBackgroundDrawable(sBackground);     
17.   
18.   
19.    setContentView(label);     
20.  }     

sBackground, 是一个静态的变量，但是我们发现，我们并没有显式的保存Contex的引用，但是，当Drawable与View连接之后，Drawable就将View设置为一个回调，由于View中是包含Context的引用的，所以，实际上我们依然保存了Context的引用。这个引用链如下：
Drawable->TextView->Context 
所以，最终该Context也没有得到释放，也发生了内存泄露。 
那我们如何的避免这种泄露的发生呢？ 
第一，应该尽量避免static成员变量引用资源耗费过多的实例，比如Context。 
第二、Context尽量使用Application Context，因为Application的Context的生命周期比较长，引用它不会出现内存泄露的问题。 
第三、使用WeakReference代替强引用。比如可以使用WeakReference<Context> mContextRef; 
该部分的详细内容也可以参考Android文档中Article部分。 
*2、 Context泄漏* 
第一条说的static泄露中，已经概括了大部分的context泄露，出了这种static的泄露context的方式外，还有一种就是内部类持有外部对象造成的内存泄露，常见是内部线程造成的。

[java]  view plain copy

1.  public class BasicActivity extends Activity {     
2.    @Override     
3.    public void onCreate(Bundle savedInstanceState) {     
4.        super.onCreate(savedInstanceState);     
5.        setContentView(R.layout.main);     
6.        new MyThread().start();     
7.    }     
8.   
9.   
10.    private class OneThread extends Thread{     
11.        @Override     
12.        public void run() {     
13.            super.run();     
14.            //do somthing     
15.        }     
16.    }     
17. }     

这段代码很平常也很简单，是我们经常使用的形式。我们思考一个问题：假设OneThread的run函数是一个很费时的操作，当我们开启该线程后，将设备的横屏变为了竖屏，一般情况下当屏幕转换时会重新创建Activity，按照我们的想法，老的Activity应该会被销毁才对，然而事实上并非如此。

由于我们的线程是Activity的内部类，所以OneThread中保存了Activity的一个引用，当OneThread的run函数没有结束时，OneThread是不会被销毁的，因此它所引用的老的Activity也不会被销毁，因此就出现了内存泄露的问题。
有些人喜欢用Android提供的AsyncTask，但事实上AsyncTask的问题更加严重，Thread只有在run函数不结束时才出现这种内存泄露问题，然而AsyncTask内部的实现机制是运用了ThreadPoolExcutor,该类产生的Thread对象的生命周期是不确定的，是应用程序无法控制的，因此如果AsyncTask作为Activity的内部类，就更容易出现内存泄露的问题,故一般不建议将AsyncTask作为内部类使用。
那么上述内存泄露问题应该如何解决呢？ 
第一、将线程的内部类，改为静态内部类。并且注意第二条。 
第二、在线程内部采用弱引用保存Context引用。 
*3、bitmap内存泄露* 
可以说出现OutOfMemory问题的绝大多数人，都是因为Bitmap的问题。因为Bitmap占用的内存实在是太多了，它是一个“超级大胖子”，特别是分辨率大的图片，如果要显示多张那问题就更显著了。
如何解决Bitmap带给我们的内存问题？ 
第一、及时的销毁。 
虽然，系统能够确认Bitmap分配的内存最终会被销毁，但是由于它占用的内存过多，所以很可能会超过java堆的限制。因此，在用完Bitmap时，要及时的recycle掉。recycle并不能确定立即就会将Bitmap释放掉，但是会给虚拟机一个暗示：“该图片可以释放了”, 还有就是， 虽然recycle()从源码上看，调用它应该能立即释放Bitmap的主要内存，但是测试表明它并没能立即释放内存。故我们还需手动设置为NULL这样还能大大的加速Bitmap的主要内存的释放。。
如下： 

[java]  view plain copy

1. if(!bitmap.isRecycled()){   
2.           bitmap.recycle()   
3. }    

第二、设置一定的采样率。 
有时候，我们要显示的区域很小，没有必要将整个图片都加载出来，而只需要记载一个缩小过的图片，这时候可以设置一定的采样率，那么就可以大大减小占用的内存。如下面的代码：

[java]  view plain copy

1. private ImageView preview;     
2. BitmapFactory.Options options = new BitmapFactory.Options();     
3. options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一     
4. Bitmap bitmap = BitmapFactory.decodeStream(cr.openInputStream(uri), null, options);     
5. preview.setImageBitmap(bitmap);     
6. 第三、巧妙的运用软引用（SoftRefrence）   
7. 有些时候，我们使用Bitmap后没有保留对它的引用，因此就无法调用Recycle函数。这时候巧妙的运用软引用，可以使Bitmap在内存快不足时得到有效的释放。如下例：   
8. ate class MyAdapter extends BaseAdapter {     
9.   
10. private ArrayList> mBitmapRefs = new ArrayList>();     
11. public View getView(int i, View view, ViewGroup viewGroup) {     
12.     View newView = null;     
13.     if(view != null) {     
14.         newView = view;     
15.     } else {     
16.         newView =(View)mInflater.inflate(R.layout.image_view, false);     
17.     }     
18.   
19.     Bitmap bitmap = BitmapFactory.decodeFile(mValues.get(i).fileName);     
20.     mBitmapRefs.add(new SoftReference(bitmap));     //此处加入ArrayList     
21.     ((ImageView)newView).setImageBitmap(bitmap);     
22.   
23.     return newView;     
24. }     

开源社区上有一个SoftHashMap工具类，就很好的采用了这种思想，所有，我们可以采用该容器来保存这些大内存资源。 
*4.未关闭InputStream/OutputStream* 
这个就不多说了，我们操作完输入输出流都要关闭流 
*5、调用registerReceiver()后未调用unregisterReceiver().* 
广播接收者（BroadcastReceiver）经常在应用中用到，可以在多线程任务完成后发送广播通知UI更新，也可以接收系统广播实现一些功能 
可以通过代码的方式注册： 

[java]  view plain copy

1. IntentFilter postFilter = new IntentFilter();    
2. postFilter.addAction(getPackageName() + ".background.job");    
3. this.registerReceiver(receiver, postFilter);    

当我们Activity中使用了registerReceiver()方法注册了BroadcastReceiver，一定要在Activity的生命周期内调用unregisterReceiver()方法取消注册
也就是说registerReceiver()和unregisterReceiver()方法一定要成对出现，通常我们可以重写Activity的onDestory().
*6、 构造adapter没有使用缓存contentview* 
当一个listview的子项有成千上万个时，如果我们没有采用一定的策略来重用这些资源，那应用的那点对内存，是远远不够使用的。 
在继承BaseAdapter时会让我们重写getView(int position, View convertView, ViewGroup parent)方法，
第二个参数convertView就是我们要用到的重用的对象。 
这里只讲使用方法，具体性能测试文章请见： 
ListView中getView的原理＋如何在ListView中放置多个item 
http://www.cnblogs.com/xiaowenji/archive/2010/12/08/1900579.html 
Android开发之ListView适配器（Adapter）优化 
http://shinfocom.iteye.com/blog/1231511 
*7、数据库的cursor没有关闭* 
Cursor是Android查询数据后得到的一个管理数据集合的类，正常情况下，如果查询得到的数据量较小时不会有内存问题，而且虚拟机能够保证Cusor最终会被释放掉。
然而如果Cursor的数据量特表大，特别是如果里面有Blob信息时，应该保证Cursor占用的内存被及时的释放掉，而不是等待GC来处理。并且Android明显是倾向于编程者手动的将Cursor close掉，因为在源代码中我们发现，如果等到垃圾回收器来回收时，会给用户以错误提示。
所以我们使用Cursor的方式一般如下： 

[java]  view plain copy

1. Cursor cursor = null;     
2. try {     
3.   cursor = mContext.getContentResolver().query(uri,null, null,null,null);     
4.   if(cursor != null) {     
5.       cursor.moveToFirst();     
6.       //do something     
7.   }     
8. } catch (Exception e) {     
9.   e.printStackTrace();       
10. } finally {     
11.   if (cursor != null) {     
12.      cursor.close();     
13.   }     
14.      

有一种情况下，我们不能直接将Cursor关闭掉，这就是在CursorAdapter中应用的情况，但是注意，CursorAdapter在Acivity结束时并没有自动的将Cursor关闭掉，因此，你需要在onDestroy函数中，手动关闭。

[java]  view plain copy

1. @Override     
2. protected void onDestroy() {           
3.    if (mAdapter != null && mAdapter.getCurosr() != null) {     
4.        mAdapter.getCursor().close();     
5.    }     
6.    super.onDestroy();      
7. }     

CursorAdapter中的changeCursor函数，会将原来的Cursor释放掉，并替换为新的Cursor，所以你不用担心原来的Cursor没有被关闭。 
你可能会想到使用Activity的managedQuery来生成Cursor，这样Cursor就会与Acitivity的生命周期一致了，多么完美的解决方法！然而事实上managedQuery也有很大的局限性。
managedQuery生成的Cursor必须确保不会被替换，因为可能很多程序事实上查询条件都是不确定的，因此我们经常会用新查询的Cursor来替换掉原先的Cursor。因此这种方法适用范围也是很小。
*总结* 

要减小内存的使用，其实还有很多方法和要求。比如不要使用整张整张的图，尽量使用9path图片。Adapter要使用convertView等等，好多细节都可以节省内存。这些都需要我们去挖掘，谁叫Android的内存不给力来着。其实，最后说一句，最最重要的就是：正确使用，规范编程。 

对于一些Android项目，影响性能瓶颈的主要是Android自己内存管理机制问题，目前手机厂商对RAM都比较吝啬，对于软件的流畅性来说RAM对性能的影响十分敏感，除了 优化Dalvik虚拟机的堆内存分配外，我们还可以强制定义自己软件的对内存大小，我们使用Dalvik提供的 dalvik.system.VMRuntime类来设置最小堆内存为例:

private final static int CWJ_HEAP_SIZE = 6* 1024* 1024 ;

VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE); //设置最小heap内存为6MB大小。当然对于内存吃紧来说还可以通过手动干涉GC去处理


bitmap 设置图片尺寸，避免 内存溢出 OutOfMemoryError的优化方法
★android 中用bitmap 时很容易内存溢出，报如下错误：Java.lang.OutOfMemoryError : bitmap size exceeds VM budget

● 主要是加上这段：
BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;

● eg1：(通过Uri取图片)
private ImageView preview;
BitmapFactory.Options options = new BitmapFactory.Options();
                    options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一
                    Bitmap bitmap = BitmapFactory.decodeStream(cr
                            .openInputStream(uri), null, options);
                    preview.setImageBitmap(bitmap);
以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出。
● eg2:（通过路径去图片）
private ImageView preview;
private String fileName= "/sdcard/DCIM/Camera/2010-05-14 16.01.44.jpg";
BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一
                        Bitmap b = BitmapFactory.decodeFile(fileName, options);
                        preview.setImageBitmap(b);
                        filePath.setText(fileName);

★Android 还有一些性能优化的方法：
●  首先内存方面，可以参考 Android堆内存也可自己定义大小 和 优化Dalvik虚拟机的堆内存分配

●  基础类型上，因为Java没有实际的指针，在敏感运算方面还是要借助NDK来完成。这点比较有意思的是Google 推出NDK可能是帮助游戏开发人员，比如OpenGL ES的支持有明显的改观，本地代码操作图形界面是很必要的。

●  图形对象优化，这里要说的是Android上的Bitmap对象销毁，可以借助recycle()方法显示让GC回收一个Bitmap对象，通常对一个不用的Bitmap可以使用下面的方式，如

if(bitmapObject.isRecycled()==false) //如果没有回收  
         bitmapObject.recycle();   

●  目前系统对动画支持比较弱智对于常规应用的补间过渡效果可以，但是对于游戏而言一般的美工可能习惯了GIF方式的统一处理，目前Android系统仅能预览GIF的第一帧，可以借助J2ME中通过线程和自己写解析器的方式来读取GIF89格式的资源。

● 对于大多数Android手机没有过多的物理按键可能我们需要想象下了做好手势识别 GestureDetector 和重力感应来实现操控。通常我们还要考虑误操作问题的降噪处理。

Android堆内存也可自己定义大小

   对于一些大型Android项目或游戏来说在算法处理上没有问题外，影响性能瓶颈的主要是Android自己内存管理机制问题，目前手机厂商对RAM都比较吝啬，对于软件的流畅性来说RAM对性能的影响十分敏感，除了上次Android开发网提到的优化Dalvik虚拟机的堆内存分配外，我们还可以强制定义自己软件的对内存大小，我们使用Dalvik提供的 dalvik.system.VMRuntime类来设置最小堆内存为例:

private final static int CWJ_HEAP_SIZE = 6* 1024* 1024 ;

VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE); //设置最小heap内存为6MB大小。当然对于内存吃紧来说还可以通过手动干涉GC去处理，我们将在下次提到具体应用。

优化Dalvik虚拟机的堆内存分配

对于Android平台来说，其托管层使用的Dalvik JavaVM从目前的表现来看还有很多地方可以优化处理，比如我们在开发一些大型游戏或耗资源的应用中可能考虑手动干涉GC处理，使用 dalvik.system.VMRuntime类提供的setTargetHeapUtilization方法可以增强程序堆内存的处理效率。当然具体原理我们可以参考开源工程，这里我们仅说下使用方法:   private final static floatTARGET_HEAP_UTILIZATION = 0.75f; 在程序onCreate时就可以调用 VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION); 即可。