Java编程中经常容易被忽视，但本身又十分重要的一个问题就是内存使用的问题。Android应用主要使用Java语言编写，因此这个问题也同样会在Android开发中出现。Android主要应用在嵌入式设备当中，而嵌入式设备由于一些众所周知的条件限制，通常都不会有很高的配置，特别是内存是比较有限的。如果我们编写的代码当中有太多的对内存使用不当的地方，难免会使得我们的设备运行缓慢，甚至是死机。为了能够使得Android应用程序安全且快速的运行，Android的每个应用程序都会使用一个专有的Dalvik虚拟机实例来运行，它是由Zygote服务进程孵化出来的，也就是说每个应用程序都是在属于自己的进程中运行的。一方面，如果程序在运行过程中出现了内存泄漏的问题，仅仅会使得自己的进程被kill掉，而不会影响其他进程(如果是system_process等系�
进程出问题的话，则会引起系统重启)。另一方面Android为不同类型的进程分配了不同的内存使用上限，如果应用进程使用的内存超过了这个上限，则会被系统视为内存泄漏，从而被kill掉。
然而内存的消耗甚至泄露是不可避免的，那么首先只有养成良好的编程习惯，尽量做到减少内存的使用，尽可能的使垃圾内存得到回收，这才是解决问题的根本途径，那么我们该怎样编写代码呢？以下是本人的一些拙见以及网上达人们得一点点小小的建议：
(一) 查询数据库没有关闭游标
程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。我觉得可以这样做：
1
2
3
4
5
6
7
8
9
10
Cursor c = sqliteDb.query(TABLE_WORDS,
word_full_projection,selection, null,
null, null,
null);
int numRows =
c.getCount();
if(numRows
> 0){
c.moveToFirst();
wordProfile account = new wordProfile();
account.createFromDb(c);
c.close();
return account;
}
c.close();
可以采取将cursor里的值赋值给实现Parcelable的类的成员变量，在所需要的地方相应取值便是，这样编可以做到及时关闭游标，释放资源。
(二) 构造Adapter时，没有使用缓存的 convertView
以构造ListView的BaseAdapter为例，在BaseAdapter中提高了方法：
public View getView(int position, View convertView, ViewGroup parent)
来向ListView提供每一个item所需要的view对象。初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的view对象，同时ListView会将这些view对象缓存起来。当向上滚动ListView时，原先位于最上面的list item的view对象会被回收，然后被用来构造新出现的最下面的list item。这个构造过程就是由getView()方法完成的，getView()的第二个形参 View convertView就是被缓存起来的list item的view对象(初始化时缓存中没有view对象则convertView是null)。
由此可以看出，如果我们不去使用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费资源也浪费时间，也会使得内存占用越来越大。ListView回收list item的view对象的过程可以查看:
android.widget.AbsListView.java –> void addScrapView(View scrap) 方法
(三) Bitmap对象不在使用时调用recycle()释放内存
有时我们会手工的操作Bitmap对象，如果一个Bitmap对象比较占内存，当它不在被使用的时候，可以调用Bitmap.recycle()方法回收此对象的像素所占用的内存，但这不是必须的，视情况而定。
(四) 将变量的作用域设置为最小
最小化作用域意味着对垃圾收集器更快的可见。让我们举一个例子。我们有一个变量定义在方法级,当方法执行完毕后,也就是说,控制跳出方法后,则该变量将不会被引用。这也就意味着它已经可以被垃圾回收。但是如果该变量是类级的,这时垃圾回收器就需要等待直到对该类的所有的引用都被
移除后才能进行垃圾回收。优化属性的作用域是必须的。同样这也是封装原则。最小化作用域降低了通过包访问变量并减少了耦合。
(五) 仅当你确实需要时才初始化
这个的意思是在你确实需要使用对象之前才分配内存。有些时候,需要在方法的开头定义一些属性。当定义这些属性时,我们很可能在定义它们的时候对其进行初始化。
这种情况下, 如果在首次使用之前出现任何问题 (如出现异常),那么已经初始化的变量所占用的内存就被浪费了。
(六) 不要在循环中定义变量
这是大部分内存溢出的程序中的另一个常见的错误。在循环中定义和初始化变量,对于循环的每次执行,该变量实例将在内存中创建并分配内存。在循环启动后,第一个对象已经可以回收了。这种额外的内存分配也会增加垃圾回收器的负担。看一下下面的代码片段你将很容易的找出问题所在。有些时候,
确实有必要在循环内定义变量,不过一定要小心使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Vector;
public class DeclareInLoopExample {
public void
getDataIncorrect() throws Exception
{
Vector data = new Vector(11);
for (String str :
data) {
String newStr = “”;
// …Some string operations
newStr = newStr + “X” + “X”;
}
}
public void
getDataCorrect() throws Exception
{
Vector data = new Vector(11);
String newStr = “”;
for (String str :
data) {
// …Some string operations
newStr = newStr + “X” + “X”;
}
}
}
(七) 不要在循环中定义变量
这是和 String 相关的一些东西,所有对 String 进行的操作都将产生另一个 String 对象。通常我们使用的
String 链接操作,这个需要注意,它会导致一个很长的动态的查询或产生一个 toString 方法中的
String。如果我们使用+操作符来连接字符串,这些额外的对象将根据+产生。当有过多操作的时候会变成很大的开销。使用不是不变对象,如
StringBuffer 来进行字符串链接操作。
(八) 不要在循环中定义变量
这会使得垃圾回收器的工作变得比较容易。 将重对象的引用设置为
null。这将释放对中对象的引用,使得垃圾回收器能立即释放它们占用的内存。
(九) 简单的使用 finally 块
finally 块即使 try 或 catch 执行不成功的时候也会执行,也就是说即使在 try 或 catch
中出现了任何异常,finally 块中的语句绝对也会执行。将清理内存的语句放在这里以保证内存被清理。
(十) 分散对象创建或删除的时间
集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增
加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机
会。
按照以上的编程方法去写代码也许可以使你减少内存的消耗，防止内存泄露。然而当内存被慢慢的耗尽甚至出现内存泄露后，我们该怎么办呢？下面的论述也许对你定位内存泄露的原因以及找出正确的解决办法会有所帮助：
在介绍内存查看、分析工具之前，我想有必要先介绍一下相关的概念。
为何会内存溢出
我们知道JVM根据generation(代)来进行GC，根据下图所示，一共被分为young
generation(年轻代)、tenured generation(老年代)、permanent generation(永久代,
perm gen)，perm
gen(或称Non-Heap 非堆)是个异类，稍后会讲到。注意，heap空间不包括perm
gen。
当young generation的空间被填满，GC会进行minor
collection(次回收)，这次回收不涉及到heap中的其他generation，minor collection根据weak
generational hypothesis(弱年代假设)来假设young
generation中大量的对象都是垃圾需要回收，minor collection的过程会非常快。young
generation中未被回收的对象被转移到tenured generation，然而tenured
generation也会被填满，最终触发major
collection(主回收)，这次回收针对整个heap，由于涉及到大量对象，所以比minor collection慢得多。
JVM有三种垃圾回收器，分别是throughput collector，用来做并行young
generation回收，由参数-XX:+UseParallelGC启动；concurrent low pause
collector，用来做tenured
generation并发回收，由参数-XX:+UseConcMarkSweepGC启动；incremental low pause
collector，可以认为是默认的垃圾回收器。不建议直接使用某种垃圾回收器，最好让JVM自己决断，除非自己有足够的把握。
Heap中各generation空间是如何划分的？通过JVM的-Xmx=n参数可指定最大heap空间，而-Xms=n则是指定最小heap空间。在JVM初始化的时候，如果最小heap空间小于最大heap空间的话，如上图所示JVM会把未用到的空间标注为Virtual。除了这两个参数还有-XX:MinHeapFreeRatio=n和 -XX:MaxHeapFreeRatio=n来分别控制最大、最小的剩余空间与活动对象之比例。在32位Solaris
SPARC操作系统下，默认值如下，在32位windows xp下，默认值也差不多。
参数
默认值
MinHeapFreeRatio
40
MaxHeapFreeRatio
70
-Xms
3670k
-Xmx
64m
由于tenured generation的major collection较慢，所以tenured
generation空间小于young generation的话，会造成频繁的major collection，影响效率。Server
JVM默认的young generation和tenured generation空间比例为1:2，也就是说young
generation的eden和survivor空间之和是整个heap(当然不包括perm
gen)的三分之一，该比例可以通过-XX:NewRatio=n参数来控制，而Client
JVM默认的-XX:NewRatio是8。至于调整young
generation空间大小的NewSize=n和MaxNewSize=n参数就不讲了，请参考后面的资料。
young generation中幸存的对象被转移到tenured generation，但不幸的是concurrent
collector线程在这里进行major collection，而在回收任务结束前空间被耗尽了，这时将会发生Full
Collections(Full GC)，整个应用程序都会停止下来直到回收完成。Full GC是高负载生产环境的噩梦……
现在来说说异类perm gen，它是JVM用来存储无法在Java语言级描述的对象，这些对象分别是类和方法数据(与class
loader有关)以及interned strings(字符串驻留)。一般32位OS下perm
gen默认64m，可通过参数-XX:MaxPermSize=n指定，JVM
Memory Structure一文说，对于这块区域，没有更详细的文献了，神秘。
难么为神秘会内存泄露呢？要回答这个问题又要引出另外一个话题，既什么样的对象GC才会回收？当然是GC发现通过任何reference
chain(引用链)无法访问某个对象的时候，该对象即被回收。名词GC
Roots正是分析这一过程的起点，例如JVM自己确保了对象的可到达性(那么JVM就是GC Roots)，所以GC
Roots就是这样在内存中保持对象可到达性的，一旦不可到达，即被回收。通常GC Roots是一个在current
thread(当前线程)的call stack(调用栈)上的对象(例如方法参数和局部变量)，或者是线程自身或者是system
class loader(系统类加载器)加载的类以及native code(本地代码)保留的活动对象。所以GC
Roots是分析对象为何还存活于内存中的利器。知道了什么样的对象GC才会回收后，再来学习下对象引用都包含哪些吧。
从最强到最弱，不同的引用(可到达性)级别反映了对象的生命周期。
1. Strong Ref(强引用)：通常我们编写的代码都是Strong
Ref，于此对应的是强可达性，只有去掉强可达，对象才被回收。
2.Soft Ref(软引用)：对应软可达性，只要有足够的内存，就一直保持对象，直到发现内存吃紧且没有Strong
Ref时才回收对象。一般可用来实现缓存，通过java.lang.ref.SoftReference类实现。
3.Weak Ref(弱引用)：比Soft Ref更弱，当发现不存在Strong
Ref时，立刻回收对象而不必等到内存吃紧的时候。通过java.lang.ref.WeakReference和java.util.WeakHashMap类实现。
4.Phantom Ref(虚引用)：根本不会在内存中保持任何对象，你只能使用Phantom
Ref本身。一般用于在进入finalize()方法后进行特殊的清理过程，通过java.lang.ref.PhantomReference实现。
有了上面的种种我相信很容易就能把heap和perm gen撑破了吧，是的利用Strong
Ref，存储大量数据，直到heap撑破；利用interned strings(或者class loader加载大量的类)把perm
gen撑破。
关于shallow
size、retained size
Shallow
size就是对象本身占用内存的大小，不包含对其他对象的引用，也就是对象头加成员变量(不是成员变量的值)的总和。在32位系统上，对象头占用8字节，int占用4字节，不管成员变量(对象或数组)是否引用了其他对象(实例)或者赋值为null它始终占用4字节。故此，对于String对象实例来说，它有三个int成员(3*4=12字节)、一个char[]成员(1*4=4字节)以及一个对象头(8字节)，总共3*4
+1*4+8=24字节。根据这一原则，对String a=”rosen jiang”来说，实例a的shallow
size也是24字节。
Retained size是该对象自己的shallow size，加上从该对象能直接或间接访问到对象的shallow
size之和。换句话说，retained size是该对象被GC之后所能回收到内存的总和。为了更好的理解retained
size，不妨看个例子。
把内存中的对象看成下图中的节点，并且对象和对象之间互相引用。这里有一个特殊的节点GC Roots，正解！这就是reference
chain的起点。
从obj1入手，上图中蓝色节点代表仅仅只有通过obj1才能直接或间接访问的对象。因为可以通过GC
Roots访问，所以左图的obj3不是蓝色节点；而在右图却是蓝色，因为它已经被包含在retained集合内。
所以对于左图，obj1的retained size是obj1、obj2、obj4的shallow
size总和；右图的retained size是obj1、obj2、obj3、obj4的shallow
size总和。obj2的retained size可以通过相同的方式计算。
Heap Dump
heap
dump是特定时间点，java进程的内存快照。有不同的格式来存储这些数据，总的来说包含了快照被触发时java对象和类在heap中的情况。由于快照只是一瞬间的事情，所以heap
dump中无法包含一个对象在何时、何地(哪个方法中)被分配这样的信息。
在不同平台和不同java版本有不同的方式获取heap dump，而MAT需要的是HPROF格式的heap
dump二进制文件。想无需人工干预的话，要这样配置JVM参数：-XX:-HeapDumpOnOutOfMemoryError，当错误发生时，会自动生成heap
dump，在生产环境中，只有用这种方式。如果你想自己控制什么时候生成heap
dump，在Windows+JDK6环境中可利用JConsole工具，而在Linux或者Mac OS
X环境下均可使用JDK5、6自带的jmap工具。当然，还可以配置JVM参数：-XX:+HeapDumpOnCtrlBreak，也就是在控制台使用Ctrl+Break键来生成heap
dump。由于我是windows+JDK5，所以选择了-XX:-HeapDumpOnOutOfMemoryError这种方式，更多配置请参考MAT Wiki。
那么下面让我们一起来看看内存泄露调试：
一开始不得不说说ClassLoader，本质上，它的工作就是把磁盘上的类文件读入内存，然后调用java.lang.ClassLoader.defineClass方法告诉系统把内存镜像处理成合法的字节码。Java提供了抽象类ClassLoader，所有用户自定义类装载器都实例化自ClassLoader的子类。system
class loader在没有指定装载器的情况下默认装载用户类，在Sun Java
1.5中既sun.misc.Launcher$AppClassLoader。更详细的内容请参看下面的资料。
(一)内存监测工具 DDMS –> Heap
无论怎么小心，想完全避免bad code是不可能的，此时就需要一些工具来帮助我们检查代码中是否存在会造成内存泄漏的地方。Android tools中的DDMS就带有一个很不错的内存监测工具Heap(这里我使用eclipse的ADT插件，并以真机为例，在模拟器中的情况类似)。用Heap监测应用进程使用内存情况的步骤如下：
1. 启动eclipse后，切换到DDMS透视图，并确认Devices视图、Heap视图都是打开的；
2. 将手机通过USB链接至电脑，链接时需要确认手机是处于“USB调试”模式，而不是作为“Mass Storage”；
3. 链接成功后，在DDMS的Devices视图中将会显示手机设备的序列号，以及设备中正在运行的部分进程信息；
4. 点击选中想要监测的进程，比如system_process进程；
5. 点击选中Devices视图界面中最上方一排图标中的“Update Heap”图标；
6. 点击Heap视图中的“Cause GC”按钮；
7. 此时在Heap视图中就会看到当前选中的进程的内存使用量的详细情况［如图所示］。
说明：
a) 点击“Cause GC”按钮相当于向虚拟机请求了一次gc操作；
b) 当内存使用信息第一次显示以后，无须再不断的点击“Cause GC”，Heap视图界面会定时刷新，在对应用的不断的操作过程中就可以看到内存使用的变化；
c) 内存使用信息的各项参数根据名称即可知道其意思，在此不再赘述。
如何才能知道我们的程序是否有内存泄漏的可能性呢。这里需要注意一个值：Heap视图中部有一个Type叫做data object，即数据对象，也就是我们的程序中大量存在的类类型的对象。在data object一行中有一列是“Total Size”，其值就是当前进程中所有Java数据对象的内存总量，一般情况下，这个值的大小决定了是否会有内存泄漏。可以这样判断：
a) 不断的操作当前应用，同时注意观察data object的Total Size值；
b) 正常情况下Total Size值都会稳定在一个有限的范围内，也就是说由于程序中的的代码良好，没有造成对象不被垃圾回收的情况，所以说虽然我们不断的操作会不断的生成很多对象，而在虚拟机不断的进行GC的过程中，这些对象都被回收了，内存占用量会会落到一个稳定的水平；
c) 反之如果代码中存在没有释放对象引用的情况，则data object的Total Size值在每次GC后不会有明显的回落，随着操作次数的增多Total Size的值会越来越大，
直到到达一个上限后导致进程被kill掉。
总之，使用DDMS的Heap视图工具可以很方便的确认我们的程序是否存在内存泄漏的可能性。
(二)内存分析工具 MAT(Memory Analyzer Tool)
如果使用DDMS确实发现了我们的程序中存在内存泄漏，那又如何定位到具体出现问题的代码片段，最终找到问题所在呢？如果从头到尾的分析代码逻辑，那肯定会把人逼疯，特别是在维护别人写的代码的时候。这里介绍一个极好的内存分析工具 – Memory Analyzer Tool(MAT)。
MAT是一个Eclipse插件，同时也有单独的RCP客户端。官方下载地址、MAT介绍和详细的使用教程请参见：www.eclipse.org/mat，在此不进行说明了。另外在MAT安装后的帮助文档里也有完备的使用教程。在此仅举例说明其使用方法。我自己使用的是MAT的eclipse插件，使用插件要比RCP稍微方便一些。
使用MAT进行内存分析需要几个步骤，包括：生成.hprof文件、打开MAT并导入.hprof文件、使用MAT的视图工具分析内存。以下详细介绍。
我们先来看一个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package org.rosenjiang.bo;
public class ithouge{
String name;
int age;
public ithouge(String a, int b){
name = a;
age = b;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package org.rosenjiang.test;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.rosenjiang.bo.Pilot;
public class OOMHeapTest
{
public static void
main(String[] args){
oom();
}
private static void
oom(){
Map map = new
HashMap();
Object[] array = new Object[1000000];
for(int
i=0;
i<1000000;
i++){
String d = new Date().toString();
ithouge p = new ithouge(d,
i);
map.put(i+”rosen jiang”, p);
array[i]=p;
}
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
