Android之NDK开发
一、NDK产生的背景
Android平台从诞生起，就已经支持C、C++开发。众所周知，Android的SDK基于Java实现，这意味着基于Android SDK进行开发的第三方应用都必须使用Java语言。但这并不等同于“第三方应用只能使用Java”。在Android SDK首次发布时，Google就宣称其虚拟机Dalvik支持JNI 编程方式，也就是第三方应用完全可以通过JNI调用自己的C动态库，即在Android平台上，“Java+C”的编程方式是一直都可以实现的。
不过，Google也表示，使用原生SDK编程相比Dalvik虚拟机也有一些劣势，Android SDK 文档里，找不到任何JNI方面的帮助。即使第三方应用开发者使用JNI完成了自己的C动态链接库（so）开发，但是so如何和应用程序一起打包成apk并发布？这里面也存在技术障碍。比如程序更加复杂，兼容性难以保障，无法访问Framework API，Debug难度更大等。开发者需要自行斟酌使用。
于是NDK就应运而生了。NDK全称是Native Development Kit。
NDK的发布，使“Java+C”的开发方式终于转正，成为官方支持的开发方式。NDK将是Android 平台支持C开发的开端。
二、为什么使用NDK
1.代码的保护。由于apk的java层代码很容易被反编译，而C/C++库反汇难度较大。
2.可以方便地使用现存的开源库。大部分现存的开源库都是用C/C++代码编写的。
3.提高程序的执行效率。将要求高性能的应用逻辑使用C开发，从而提高应用程序的执行效率。
4.便于移植。用C/C++写得库可以方便在其他的嵌入式平台上再次使用。
三、NDK简介
1.NDK是一系列工具的集合
NDK提供了一系列的工具，帮助开发者快速开发C（或C++）的动态库，并能自动将so和java应用一起打包成apk。这些工具对开发者的帮助是巨大的。
NDK集成了交叉编译器，并提供了相应的mk文件隔离CPU、平台、ABI等差异，开发人员只需要简单修改mk文件（指出“哪些文件需要编译”、“编译特性要求”等），就可以创建出so。
NDK可以自动地将so和Java应用一起打包，极大地减轻了开发人员的打包工作。
2.NDK提供了一份稳定、功能有限的API头文件声明
Google明确声明该API是稳定的，在后续所有版本中都稳定支持当前发布的API。从该版本的NDK中看出，这些API支持的功能非常有限，包含有：C标准库（libc）、标准数学库（libm）、压缩库（libz）、Log库（liblog）。
四、NDK开发环境的搭建
1.下载安装Android NDK
地址：https://www.doczj.com/doc/b612121967.html,/sdk/ndk/index.html
2.下载安装cygwin
由于NDK编译代码时必须要用到make和gcc，所以你必须先搭建一个linux环境，cygwin 是一个在windows平台上运行的unix模拟环境,它对于学习unix/linux操作环境，或者从unix到windows的应用程序移植，非常有用。通过它，你就可以在不安装linux的情况下使用NDK来编译C、C++代码了。下载地址：https://www.doczj.com/doc/b612121967.html,
1）然后双击运行吧，运行后你将看到安装向导界面。
2）点击下一步,此时让你选择安装方式：
?Install from Internet：直接从Internet上下载并立即安装（安装完成后，下载好的安装文件并不会被删除，而是仍然被保留，以便下次再安装）。
?Download Without Installing：只是将安装文件下载到本地，但暂时不安装。
?Install from Local Directory：不下载安装文件，直接从本地某个含有安装文件的目录进行安装。
3）选择第一项，然后点击下一步。
4）选择要安装的目录，注意，最好不要放到有中文和空格的目录里，似乎会造成安装出问题，其它选项不用变，之后点下一步：
5）上一步是选择安装cygwin的目录，这个是选择你下载的安装包所在的目录，默认是你运行setup.exe的目录，直接点下一步就可以：
6）此时你共有三种连接方式选择：
?Direct Connection：直接连接。
?Use IE5Settings：使用IE的连接参数设置进行连接。
?Use HTTP/FTP Proxy：使用HTTP或FTP代理服务器进行连接（需要输入服务器地址、端口号）。
用户可根据自己的网络连接的实情情况进行选择，一般正常情况下，均选择第一种，也就是直接连接方式。然后再点击“下一步”。
7）这是选择要下载的站点，选择后点下一步。
8）此时会下载加载安装包列表
9）Search是可以输入你要下载的包的名称，能够快速筛选出你要下载的包。那四个单选按钮是选择下边树的样式，默认就行，不用动。View默认是Category，建议改成full显示全部包再查，省的一些包被隐藏掉。左下角那个复选框是是否隐藏过期包，默认打钩，不用管它就行，下边开始下载我们要安装的包吧，为了避免全部下载，这里列出了后面开发NDK用得着的包：autoconf2.1、automake1.10、binutils、gcc-core、gcc-g++、gcc4-core、gcc4-g++、gdb、pcre、pcre-devel、gawk、make共12个包
10）然后开始选择安装这些包吧，点skip，把它变成数字版本格式，要确保Bin项变成叉号，而Src项是源码，这个就没必要选了。
11）下面测试一下cygwin是不是已经安装好了。
运行cygwin，在弹出的命令行窗口输入：cygcheck-c cygwin命令，会打印出当前cygwin 的版本和运行状态，如果status是ok的话，则cygwin运行正常。
然后依次输入gcc–version，g++--version，make–version，gdb–version进行测试，如果都打印出版本信息和一些描述信息，则cygwin安装成功！
3.配置NDK环境变量
a．首先找到cygwin的安装目录，找到一个home\<你的用户名>\.bash_profile文件，我的是：E:\cygwin\home\Administrator\.bash_profile，(注意：我安装的时候我的home文件夹下面什么都没有，解决的办法：首先打开环境变量，把里面的用户变量中的HOME变量删掉，在E:\cygwin\home文件夹下建立名为Administrator的文件夹（是用户名），然后
把E:\cygwin\etc\skel\.bash_profile拷贝到该文件夹下)。
b．打开bash_profile文件，添加NDK=/cygdrive/<你的盘符>/
NDK=/cygdrive/e/android-ndk-r5
export NDK
NDK这个名字是随便取的，为了方面以后使用方便，选个简短的名字，然后保存
c．打开cygwin，输入cd$NDK，如果输出上面配置的/cygdrive/e/android-ndk-r5信息，则表明环境变量设置成功了。
4.用NDK来编译程序
a．现在我们用安装好的NDK来编译一个简单的程序吧，我们选择ndk自带的例子hello-jni，我的位于E:\android-ndk-r5\samples\hello-jni(根据你具体的安装位置而定)，
b．运行cygwin，输入命令cd/cygdrive/e/android-ndk-r5/samples/hello-jni，进入到E:\android-ndk-r5\samples\hello-jni目录。
c．输入$NDK/ndk-build，执行成功后，它会自动生成一个libs目录，把编译生成的.so文件放在里面。($NDK是调用我们之前配置好的环境变量，ndk-build是调用ndk的编译程序)
d．此时去hello-jni的libs目录下看有没有生成的.so文件，如果有，你的ndk就运行正常啦！
5.在eclipse中集成c/c++开发环境
a．装Eclipse的C/C++环境插件：CDT，这里选择在线安装。首先登
录https://www.doczj.com/doc/b612121967.html,/cdt/downloads.php，找到对应你Eclipse版本的CDT插件的在线安装地址。
b．然后点Help菜单，找到Install New Software菜单
c．点击Add按钮，把取的地址填进去，出来插件列表后，选Select All，然后选择下一步即可完成安装。
d．安装完成后，在eclispe中右击新建一个项目，如果出现了c/c++项目，则表明你的CDT插件安装成功啦！
6.配置C/C++的编译器
a．打开eclipse，导入ndk自带的hello-jni例子，右键单击项目名称，点击Properties，弹出配置界面，之后再点击Builders，弹出项目的编译工具列表，之后点击New，新添加一个编译器，点击后出现添加界面，选择Program，点击OK。
b．出现了添加界面，首先给编译配置起个名字，如：C_Builder，设
置Location为<你cygwin安装路径>\bin\bash.exe程序，例：E:\cygwin\bin\bash.exe，设置Working Directory为<你cygwin安装路径>\bin目录，例如：E:\cygwin\bin，设
置Arguments为--login-c"cd/cygdrive/e/android-ndk-r5/samples/hello-jni&& $NDK/ndk-build"
上面的配置中/cygdrive/e/android-ndk-r5/samples/hello-jni是你当前要编译的程序的目录，$NDK是之前配置的ndk的环境变量，这两个根据你具体的安装目录进行配置，其他的不用变，Arguments这串参数实际是给bash.exe命令行程序传参数，进入要编译的程序目录，然后运行ndk-build编译程序
c．接着切换到Refresh选项卡，给Refresh resources upon completion打上钩
d．然后切换到Build Options选项卡，勾选上最后三项
e．之后点击Specify Resources按钮，选择资源目录，勾选你的项目目录即可
f．最后点击Finish，点击OK一路把刚才的配置都保存下来，注意：如果你配置的编译器在其它编译器下边，记得一定要点Up按钮，把它排到第一位，否则C代码的编译晚于Java代码的编译，会造成你的C代码要编译两次才能看到最新的修改。
g．编译配置也配置完成啦，现在来测试一下是否可以自动编译呢，打开项目jni目录里
的hello-jni.c文件把提示Hello from JNI!改成其他的文字：如：Hello，My name is alex.，然后再模拟器中运行你的程序，如果模拟器中显示了你最新修改的文字，那么Congratulations！你已经全部配置成功啦！
五、开发自己的NDK程序
入门的最好办法就是学习Android自带的例子，这里就通过学习Android的NDK自带的demo 程序：hello-jni来达到这个目的。
1、开发环境的搭建
1)android的NDK开发需要在linux下进行：因为需要把C/C++编写的代码生成能在arm 上运行的.so文件，这就需要用到交叉编译环境，而交叉编译需要在linux系统下才能完成。
2)安装android-ndk开发包，这个开发包可以在google android官网下载：通过这个开发包的工具才能将android jni的C/C++的代码编译成库
3)android应用程序开发环境：包括eclipse、java、android sdk、adt等。
如何下载和安装android-ndk我这里就不啰嗦了，安装完之后，需要将android-ndk的路劲加到环境变量PATH中：
sudo gedit/etc/environment
在environment的PATH环境变量中添加你的android-ndk的安装路劲，然后再让这个更改的环境变量立即生效：
source/etc/environment
经过了上述步骤，在命令行下敲：
ndk-bulid
弹出如下的错误，而不是说ndk-build not found，就说明ndk环境已经安装成功了。
Android NDK:Could not find application project directory!
Android NDK:Please define the NDK_PROJECT_PATH variable to point to it.
/home/braincol/workspace/android/android-ndk-r5/build/core/build-local.mk:85:*** Android NDK:Aborting.Stop.
2.代码的编写
1)首先是写java代码
建立一个Android应用工程HelloJni，创建HelloJni.java文件：
HelloJni.java:
import android.app.Activity;
import android.widget.TextView;
import android.os.Bundle;
public class HelloJni extends Activity
{
/**Called when the activity is first created.*/
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
TextView tv=new TextView(this);
tv.setText(stringFromJNI());
setContentView(tv);
}
/*A native method that is implemented by the'hello-jni' native library,which is packaged with this application.*/ public native String stringFromJNI();
public native String unimplementedStringFromJNI();
/*this is used to load the'hello-jni'library on application startup.The library has already been unpacked into
/data/data/com.example.HelloJni/lib/libhello-jni.so at installation time by the package manager.*/ static{
System.loadLibrary("hello-jni");
}
}
这段代码很简单，注释也很清晰，这里只提两点：:
表明程序开始运行的时候会加载hello-jni,static区声明的代码会先于onCreate方法执行。如果你的程序中有多个类，而且如果HelloJni这个类不是你应用程序的入口，那么hello-jni（完整的名字是libhello-jni.so）这个库会在第一次使用HelloJni这个类的时候加载。
可以看到这两个方法的声明中有native关键字，这个关键字表示这两个方法是本地方法，也就是说这两个方法是通过本地代码（C/C++）实现的，在java代码中仅仅是声明。
用eclipse编译该工程，生成相应的.class文件，这步必须在下一步之前完成，因为生成.h文件需要用到相应的.class文件。
2)编写相应的C/C++代码
刚开始学的时候，有个问题会让人很困惑，相应的C/C++代码如何编写，函数名如何定义？这里讲一个方法，利用javah这个工具生成相应的.h文件，然后根据这个.h文件编写相应的C/C++代码。
a.生成相应.h文件：
就拿我这的环境来说，首先在终端下进入刚刚建立的HelloJni工程的目录：
ls查看工程文件
可以看到目前仅仅有几个标准的android应用程序的文件（夹）。首先我们在工程目录下建立一个jni文件夹：
下面就可以生成相应的.h文件了：
-classpath bin：表示类的路劲
-d jni:表示生成的头文件存放的目录
com.example.hellojni.HelloJni则是完整类名
这一步的成功要建立在已经在bin/com/example/hellojni/目录下生成了HelloJni.class 的基础之上。现在可以看到jni目录下多了个.h文件：
我们来看看com_example_hellojni_HelloJni.h的内容：
com_example_hellojni_HelloJni.h:
/*DO NOT EDIT THIS FILE-it is machine generated*/ #include
/*Header for class com_example_hellojni_HelloJni*/ #ifndef_Included_com_example_hellojni_HelloJni
#define_Included_com_example_hellojni_HelloJni
#ifdef__cplusplus
extern"C"{
#endif
/*
*Class:com_example_hellojni_HelloJni
*Method:stringFromJNI
*Signature:()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_com_example_hellojni_HelloJni_stringFromJNI (JNIEnv*,jobject);
/*
*Class:com_example_hellojni_HelloJni
*Method:unimplementedStringFromJNI
*Signature:()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_com_example_hellojni_HelloJni_unimplementedStringFro mJNI
(JNIEnv*,jobject);
#ifdef__cplusplus
}
#endif
#endif
上面代码中的JNIEXPORT和JNICALL是jni的宏，在android的jni中不需要，当然写上去也不会有错。从上面的源码中可以看出这个函数名那是相当的长啊。。。。不过还是很有规律的，完全按照：java_pacakege_class_mathod形式来命名。
也就是说：
Hello.java中stringFromJNI()方法对应于C/C++中的
Java_com_example_hellojni_HelloJni_stringFromJNI()方法
HelloJni.java中的unimplementedStringFromJNI()方法对应于C/C++中的
Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI()方法注意下其中的注释：
Signature:()Ljava/lang/String;
()Ljava/lang/String;()表示函数的参数为空（这里为空是指除了JNIEnv*,jobject这两个参数之外没有其他参数，JNIEnv*,jobject是所有jni函数必有的两个参数，分别表示jni环境和对应的java类（或对象）本身），Ljava/lang/String;表示函数的返回值是java的String对象。
b.编写相应的.c文件：
hello-jni.c:
#include
#include
/*This is a trivial JNI example where we use a native method *to return a new VM String.See the corresponding Java source *file located at:
*
apps/samples/hello-jni/project/src/com/example/HelloJni/H
elloJni.java
*/
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI(JNIEnv* env,jobject thiz)
{
return(*env)->NewStringUTF(env,"Hello from JNI!"); }
这里只是实现了Java_com_example_hellojni_HelloJni_stringFromJNI方法，而
Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI方法并没有实现，因为在HelloJni.java中只调用了stringFromJNI()方法，所以unimplementedStringFromJNI()方法没有实现也没关系，不过建议最好还是把所有java中定义的本地方法都实现了，写个空函数也行啊。。。有总比没有好。
Java_com_example_hellojni_HelloJni_stringFromJNI()函数只是简单的返回了一个内容为"Hello from JNI!"的jstring对象（对应于java中的String对象）。hello-jni.c文件已经编写好了，现在可以把com_example_hellojni_HelloJni.h文件给删了，当然留着也行，只是我还是习惯把不需要的文件给清理干净了。
3)编译hello-jni.c生成相应的库
a编写Android.mk文件
在jni目录下（即hello-jni.c同级目录下）新建一个Android.mk文件，Android.mk文件是Android的makefile文件，内容如下：
#Copyright(C)2009The Android Open Source Project
#
#Licensed under the Apache License,Version2.0(the "License");
#you may not use this file except in compliance with the License.
#You may obtain a copy of the License at
#
#https://www.doczj.com/doc/b612121967.html,/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.
#
LOCAL_PATH:=$(call my-dir)
include$(CLEAR_VARS)
LOCAL_MODULE:=hello-jni
LOCAL_SRC_FILES:=hello-jni.c
include$(BUILD_SHARED_LIBRARY)
这个Androd.mk文件很短，下面我们来逐行解释下：
LOCAL_PATH:=$(call my-dir)
一个Android.mk文件首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’,由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。
include$(CLEAR_VARS)
CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如LOCAL_MODULE,LOCAL_SRC_FILES,LOCAL_STATIC_LIBRARIES,等等...),除LOCAL_PATH。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。
LOCAL_MODULE:=hello-jni
编译的目标对象，LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。
注意：编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'hello-jni'的共享库模块，将会生成'libhello-jni.so'文件。
重要注意事项：如果你把库命名为‘libhello-jni’，编译系统将不会添加任何的lib前缀，也会生成'libhello-jni.so'，这是为了支持来源于Android平台的源代码的Android.mk文件，如果你确实需要这么做的话。
LOCAL_SRC_FILES:=hello-jni.c
LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。
注意，默认的C++源码文件的扩展名是’.cpp’.指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION变量，不要忘记开始的小圆点（也就是’.cxx’,而不是’cxx’）
include$(BUILD_SHARED_LIBRARY)
Android 应用程序内存泄漏的分析以前在学校里学习Java的时候，总是看到说，java是由垃圾收集器（GC）来管理内存回收的，所以当时形成的观念是Java不会产生内存泄漏，我们可以只管去申请内存，不需要关注内存回收，GC会帮我们完成。呵呵，很幼稚的想法，GC没那么聪明啊，理论及事实证明，我们的Java程序也是会有内存泄漏的。 （一）Java内存泄漏从何而来 一般来说内存泄漏有两种情况。一种情况如在C/C++语言中的，在堆中的分配的内存，没有将其释放，或者是在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉（如指针重新赋值）；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在Java中已经由于垃圾回收机制的引入，得到了很好的解决。所以，Java中的内存泄漏，主要指的是第二种情况。 （二）需要的工具 1.DDMS—Update heap Gause GC Heap 是DDMS自带的一个很不错的内存监控工具，下图红色框中最左边的图标就是该 工具的启动按钮，它能在Heap视图中显示选中进程的当前内存使用的详细情况。下图 框中最右边的是GC工具，很多时候我们使用Heap监控内存的时候要借助GC工具，点 击一次GC按钮就相当于向VM请求了一次GC操作。中间的按钮是Dump HPROF file，它 的功能相当于给内存拍一张照，然后将这些内存信息保存到hprof文件里面，在使用我 们的第二个工具MAT的时候会使用到这个功能。 2.MAT(Memory Analyzer Tool) Heap工具能给我们一个感性的认识，告诉我们程序当前的内存使用情况和是否存在内存 泄漏的肯能性。但是，如果我们想更详细，更深入的了解内存消耗的情况，找到问题所 在，那么我们还需要一个工具，就是MAT。这个工具是需要我们自己去下载的，可以下 载独立的MAT RCP 客户端，也可以以插件的形式安装到Eclipse里面，方便起见，推荐 后者。 安装方法： A．登录官网https://www.doczj.com/doc/b612121967.html,/mat/downloads.php B．下载MAT Eclipse插件安装包（红框所示，当然你也可是选择Update Site在线安装，个人觉得比较慢）
android如何查看cpu的占用率和内存泄漏 在分析内存优化的过程中，其中一个最重要的是我们如何查看cpu的占用率和内存的占用率呢，这在一定程度上很重要，经过查询资料，研究了一下，暂时了解到大概有以下几种方式，如果哪位高手有更好的办法，或者文中描述有错误，还望高手在下面留言，非常感谢！ 一、通过eclipse，ADT开发工具的DDMS来查看(Heap) 在“Devices”窗口中选择模拟器中的一个需要查看的程序，从工具条中选“Update heap”按钮，给这个程序设置上“heap Updates”，然后在Heap视图中点击Cause GC就可以实时显示这个程序的一些内存和cpu的使用情况了。
然后就会出现如下界面： 说明： a) 点击“Cause GC”按钮相当于向虚拟机请求了一次gc操作； b) 当内存使用信息第一次显示以后，无须再不断的点击“Cause GC”，Heap视图界面会定
时刷新，在对应用的不断的操作过程中就可以看到内存使用的变化； c) 内存使用信息的各项参数根据名称即可知道其意思，在此不再赘述。 大致解析如下： 这个就是当前应用的内存占用，allocated 是已经分配的内存free是空闲内存， heap size 是虚拟机分配的不是固定值 heap size 的最大值跟手机相关的 有网友说， 一般看1byte的大部分就是图片占用的 如何判断应用是否有内存泄漏的可能性呢？ 如何才能知道我们的程序是否有内存泄漏的可能性呢。这里需要注意一个值：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掉。
随着技术的发展，智能手机硬件配置越来越高，可是它和现在的PC相比，其运算能力，续航能力，存储空间等都还是受到很大的限制，同时用户对手机的体验要求远远高于PC的桌面应用程序。以上理由，足以需要开发人员更加专心去实现和优化你的代码了。选择合适的算法和数据结构永远是开发人员最先应该考虑的事情。同时，我们应该时刻牢记，写出高效代码的两条基本的原则：（1）不要做不必要的事；（2）不要分配不必要的内存。 我从去年开始接触Android开发，以下结合自己的一点项目经验，同时参考了Google的优化文档和网上的诸多技术大牛给出的意见，整理出这份文档。 1. 内存优化 Android系统对每个软件所能使用的RAM空间进行了限制(如：Nexus o ne 对每个软件的内存限制是24M)，同时Java语言本身比较消耗内存，d alvik虚拟机也要占用一定的内存空间，所以合理使用内存，彰显出一个程序员的素质和技能。 1) 了解JIT 即时编译（Just-in-time Compilation，JIT），又称动态转译（Dynamic Translation），是一种通过在运行时将字节码翻译为机器码，从而改善字节码编译语言性能的技术。即时编译前期的两个运行时理论是字节码编译和动态编译。Android原来Dalvik虚拟机是作为一种解释器实现，新版
（Android2.2+）将换成JIT编译器实现。性能测试显示，在多项测试中新版本比旧版本提升了大约6倍。 详细请参考https://www.doczj.com/doc/b612121967.html,/cool_parkour/blog/item/2802b01586e22cd8a6ef3f6b. html 2) 避免创建不必要的对象 就像世界上没有免费的午餐，世界上也没有免费的对象。虽然gc为每个线程都建立了临时对象池，可以使创建对象的代价变得小一些，但是分配内存永远都比不分配内存的代价大。如果你在用户界面循环中分配对象内存，就会引发周期性的垃圾回收，用户就会觉得界面像打嗝一样一顿一顿的。所以，除非必要，应尽量避免尽力对象的实例。下面的例子将帮助你理解这条原则： 当你从用户输入的数据中截取一段字符串时，尽量使用substring函数取得原始数据的一个子串，而不是为子串另外建立一份拷贝。这样你就有一个新的String对象，它与原始数据共享一个char数组。如果你有一个函数返回一个String对象，而你确切的知道这个字符串会被附加到一个Stri ngBuffer，那么，请改变这个函数的参数和实现方式，直接把结果附加到StringBuffer中，而不要再建立一个短命的临时对象。 一个更极端的例子是，把多维数组分成多个一维数组： int数组比Integer数组好，这也概括了一个基本事实，两个平行的int数组比(int,int)对象数组性能要好很多。同理，这试用于所有基本类型的组合。如果你想用一种容器存储(Foo,Bar)元组，尝试使用两个单独的Foo[]
android因其系统的特殊性,安装的软件默认都安装到内存中,所以随着 用户安装的软件越来越多,可供运行的程序使用的内存越来越小,这就要求我们在开发android程序时,尽可能的少占用内存。根据我个人的开发经验总结了如下几点优化内存的方法: 1创建或其他方式获得的对象如不再使用,则主动将其置为null。 2尽量在程序中少使用对图片的放大或缩小或翻转.在对图片进行操作时占用的内存可能比图片本身要大一些。 3调用图片操作的后，及时的清空，调用recycle()提醒经行垃圾回收。 4尽可能的将一些静态的对象(尤其是集合对象),放于SQLite数据库中。并且对这些数据的搜索匹配尽可能使用sql语句进行。 5一些连接资源在不使用使应该释放,如数据库连接文件输入输出流等。应该避免在特殊的情况下不释放(如异常或其他情况) 6一些长周期的对像引用了短周期的对象,但是这些短周期的对象可能只在很小的范围内使用。所以在查内存中也应该清除这一隐患。如果你想写一个Java程序，观察某对象什么时候会被垃圾收集的执行绪清除，你必须要用一个reference记住此对象，以便随时观察，但是却因此造成此对象的reference数目一直无法为零，使得对象无法被清除。 https://www.doczj.com/doc/b612121967.html,ng.ref.WeakReference 不过，现在有了Weak Reference之后，这就可以迎刃而解了。如果你希望能随时取得某对象的信息，但又不想影响此对象的垃圾收集，那
么你应该用Weak Reference来记住此对象，而不是用一般的reference。 A obj=new A(); WeakReference wr=new WeakReference(obj); obj=null; //等待一段时间，obj对象就会被垃圾回收 … if(wr.get()==null){ System.out.println(“obj已经被清除了“); }else{ System.out.println(“obj尚未被清除，其信息是 “+obj.toString()); } … 在此例中，透过get()可以取得此Reference的所指到的对象，如果传出值为null的话，代表此对象已经被清除。 这类的技巧，在设计Optimizer或Debugger这类的程序时常会用到，因为这类程序需要取得某对象的信息，但是不可以影响此对象的垃圾收集。 https://www.doczj.com/doc/b612121967.html,ng.ref.SoftReference Soft Reference虽然和Weak Reference很类似，但是用途却不同。被Soft Reference指到的对象，即使没有任何Direct Reference，也不会被清除。一直要到JVM内存不足时且没有Direct Reference
大家好,今天我主要来和大家交流下低端ａndrｏid手机内存优化的问题。 一、问题的引出 前天,我在论坛发了一个帖子，想请教大家关于联想A68e内存优化的问题,但是回复者寥寥无几,课件也很少有机油对这方面有较深入的 学习了解。我今天中午，查了有关资料,也用了自己的手机进行了测试,觉得可能对A６８ｅ（其实是广大低端Ａndroｉｄ手机)用户有点帮助,所以特地来分享以下。（说明:本人用的是Sumsumg I9１03,我媳妇用的是电信套餐的联想Ａ68e，这几天我没拿到她的手机来测试，所以只能自己的手机进行测试，但是我觉得还是具有一定的参考价值的）。二、ROＭ和RAM 首先，我先解释一下ROM和RＡM的区别。 ＲOＭ是Read Onlｙ Memory,即只读存储器；RAM是Aｃｃｅss Random Meｍorｙ,即随即读写存储器。 ＲＯＭ是存储程序和数据的,类别电脑的硬盘，可以存放安装的程序、文件、数据等。而论坛中有开AｐpEXT２的方法(我没试过),那个只是节省出更多的ＲOＭ空间,这样可以使程序运行得更为流畅，但是不能解决“同时运行程序的数量最大值太小”的问题。以Ａ６8e为例,如果开一个QQ、音乐播放器，再开个UC浏览器估计机子就崩溃而导致程序退出。 RAM才是程序运行时所占用的物理空间。RAM的价格比ROM贵很多，所以RＡM的大小一半程度上决定了机子的价位（另一半就是CＰＵ）。
我的Suｍsuｎg是1G RAM，同时开QQ、QQ游戏、ＱQ音乐、浏览器、微信等七、八个程序也毫无压力。所以RAM太小是影响A６8ｅ（包括很多Android手机)用户体验的原因。如果你是个游戏玩家、手机达人,那么这类机子一定不适合你。如果你希望能像有高端机那样的用户体验,我建议你还是多话点银子购买配置高的Aｎdroiｄ手机。 关于官方宣传256的RＡＭ实际上只有１70，那是有一部分被Anｄroid系统占用。我的手机1ＧRAＭ,实际上也只有724M。 三、Ａnｄroｉｄ系统内存管理机制及进程调度机制 下面开始具体的分析了。 首先Andrｏiｄ系统是基于Ｌinux 内核开发的开源操作系统，li ｎuｘ系统的内存管理有其独特的动态存储管理机制。Anｄroid采取了一种有别于Linux的进程管理策略，Liｎuｘ系统在进程活动停止后就结束该进程,而Andrｏid把这些进程都保留在内存中,直到系统需要更多内存为止。这些保留在内存中的进程通常情况下不会影响整体系统的运行速度，并且当用户再次激活这些进程时,提升了进程的启动速度。 Androｉｄ系统这样的设计不仅非常适合移动终端(手机、平板）的需要,而且减少了系统崩溃的可能,确保了系统的稳定性。老想着清理内存的同学完全是因为被塞班或者Ｗiｎｄoｗs毒害太深,事实上,经常用Taskilleｒ之类的软件关闭后台所有进程,很容易造成系统的不稳定。很多时候出现问题了，只要重启就能解决的原因也在于此。 广大机油一定会发现,关闭了QQ、微信等程序后，其实并没有完全关闭这些程序。这些程序在后台占用了一定的内存,但是并没有运行时
Android减少内存占用专题 Android开发经验：不要动不动就分配内存 2011-03-21 开发Andorid应用的开发者都知道，要尽量减少new关键字的使用，因为在手机上GC释放一次内存是一件恐怖的事情，如果你查看一下调试记录，你会发现GC释放内存时有时会花上几百毫秒的时间。可以想象，如果你开发的是游戏，这时你的FPS会下降到多少。 虽然这个原则大家都知道，我们还是会看到一些开发者会出现类似问题，这又是为什么呢？呵呵，其实这是一些隐式的对象创建在作怪，看看以下代码： 原则1：如果可能，请不要使用可变参数 当外部调用时： 系统会自动创建一个临时的数组对象，类似于： 如果该函数经常被调用，则会极大增加GC的压力。所以，如果可能，请不要使用可变参数。 原则2：如果可能，请用StringBuilder代替字符串的相加 我们来看一段代码： 系统会将这句翻译成为如下格式： 这本身没有什么问题，但如果是如下就有意思了： 这段代码等效于：
这样是不是悲剧，本来StringBuilder被无意义的重复创建了多次，期间还在数字转换到文本时创建了String，所以请直接使用显示的StringBuilder来链接字符串。 原则3：尽量将不变的东东设置为常数，特别是字符串 较有效的办法是，你的代码可以这样来写： 当然，即使这样做了，后续对文本操作（如整数到文本转换）仍然是一件费时费力的或，原因是JAVA中，String 是只读的，任何String的内容操作均隐含了new关键字。作者在实际工作中只好采取了更笨笨的办法，自己实现了一个GString类来替代常用的文本操作，其原理时使用预分配的字节内存，只在需要时才转换为String对象。 Android进阶：性能优化篇 2011-05-11 一、图片载入过多出现OutOfMemoryError异常 在使用Gallery控件时，如果载入的图片过多，过大，就很容易出现OutOfMemoryError异常，就是内存溢出。这是因为Android默认分配的内存只有几M，而载入的图片如果是JPG之类的压缩格式，在内存中展开时会占用大量的空间，也就容易内存溢出。这时可以用下面的方法解决： 二、统一管理位图资源，适时释放资源
性能优化 1、图片的三级缓存中,图片加载到内存中,如果内存快爆了,会发生什么？怎么处理？ ?参考回答： o首先我们要清楚图片的三级缓存是如何的 如果内存足够时不回收。内存不够时就回收软引用对象 2、内存中如果加载一张500*500的png高清图片.应该是占用多少的内存? ?参考回答： o不考虑屏幕比的话：占用内存=500 * 500 * 4 = 1000000B ≈ 0.95MB o考虑屏幕比的的话：占用内存= 宽度像素x （inTargetDensity / inDensity）x 高度像素x
（inTargetDensity / inDensity）x 一个像素所占的内存字节 大小 o inDensity表示目标图片的dpi（放在哪个资源文件夹下），inTargetDensity表示目标屏幕的dpi 3、WebView的性能优化? 参考回答： o一个加载网页的过程中，native、网络、后端处理、CPU都会参与，各自都有必要的工作和依赖关系；让他们相互并行处理 而不是相互阻塞才可以让网页加载更快： ?WebView初始化慢，可以在初始化同时先请求数据， 让后端和网络不要闲着。 ?常用JS 本地化及延迟加载，使用第三方浏览内核
?后端处理慢，可以让服务器分trunk输出，在后端计算 的同时前端也加载网络静态资源。 ?脚本执行慢，就让脚本在最后运行，不阻塞页面解析。 ?同时，合理的预加载、预缓存可以让加载速度的瓶颈更 小。 ?WebView初始化慢，就随时初始化好一个WebView 待用。 ?DNS和链接慢，想办法复用客户端使用的域名和链接。 4、Bitmap如何处理大图，如一张30M的大图，如何预防OOM？ 参考回答：避免OOM的问题就需要对大图片的加载进行管理，主要通过缩放来减小图片的内存占用。 o BitmapFactory提供的加载图片的四类方法（decodeFile、decodeResource、decodeStream、decodeByteArray） 都支持BitmapFactory.Options参数，通过inSampleSize参 数就可以很方便地对一个图片进行采样缩放
Android中内存优化的那些事一个有关图片的优化记录 客服群里叫喊着：这个用户图片不显示了，那个用户图片也不显示了。我拿着手上一切正常的测试机，what the hell…… 默默地打开bugly。 满园春色关不住，遍地内存溢出来!是的，又闯祸了! 内存问题永远是既陌生又熟悉的话题，而且大多数都发生在一个叫作用户家的手机上。安卓系统本身不断的在优化，三方框架也逐渐成熟，外加手机厂商的大内存加持，似乎内存问题变得少见，但还是不能忽视。 借着这次修复内存问题的记录，分享一些“自以为”的解决思路，仅供参考。ok,let’s go! 修复问题的三部曲，先复现，再定位，最后修复。 复现 估计有的人会说，异常现象都在那，有啥好复现的，冲进代码直接开干。 修复bug永远是个惊心动魄的事，稍微一不小心就有可能天崩地裂。不是修复不完全，就是引入新问题。从起因开始了解整个缘由，一方面能加深对问题的理解，同时确保最终能验证问题是否得到修复。 内存的问题经常发生在一些比较特殊的环境下，而且很多时候不一定是必现，往往体现在一些中低端机型上。所以从机型上入手可能会是一个不错的选择。 最终，通过bugly查到了对应的问题机型及系统版本，上各类云测平台找到了台云测试机。按照进入问题页面的几个固定流程，反复执行，最终锁定了复现流程。
定位 知道问题如何复现，接下来就是定位问题到底出在哪。通常内存的问题，会碰到两种情况： 1.内存堆积：由于特殊情况造成的页面关闭但资源还遗漏在内存中。 2.内存高占用：由于业务需要或者使用不当导致内存占用量过高。 我们先来看看这次的问题属于哪种情况。 在Android Studio2.3及之前版本上自带的Android monitor中，可以直观的反应出当前应用的整体内存使用水平。[如何使用工具的分享估计大家都看腻了，这次就不再重复了。 142MB!!!!进入事故现场之前就已经被占用了这么多内存。难怪之后会内存异常。看来这次要先解决内存高占用的问题，我们先要详细的了解内存的具体情况，才知道从哪下手去解决，无论是避免无意义的使用或者优化必要的占用。 先强制gc一下，然后dump java heap，看一下整体内存里的情况，按照shallow size排序。 首当其冲的byte数组映入眼帘，大家都明白的，bitmap一直都是大客户。我们接着分析下byte[]中的各个对象。
Android手机内存进程优化设置技巧
Android采取了一种有别于Linux的进程管理策略，有别于Linux的在进程活动停止后就结束该进程，Android把这些进程都保留在内存中，直到系统需要更多内存为止。这些保留在内存中的进程通常情况下不会影响整体系统的运行速度，并且当用户再次激活这些进程时，提升了进程的启动速度。 那Android什么时候结束进程?结束哪个进程呢?之前普遍的认识是Android是依据一个名为LRU(last recently used 最近使用过的程序)列表，将程序进行排序，并结束最早的进程。XDA 的楼主又进一步对这个管理机制进行研究，有了如下发现： 系统会对进程的重要性进行评估，并将重要性以“oom_adj”这个数值表示出来，赋予各个进程;(系统会根据“oom_adj”来判断需要结束哪些进程，一般来说，“oom_adj”的值越大，该进程被系统选中终止的可能就越高) 前台程序的“oom_adj”值为0，这意味着它不会
被系统终止，一旦它不可访问后，会获得个更高的“oom_adj”，作者推测“oom_adj”的值是根据软件在LRU列表中的位置所决定的; Android不同于Linux，有一套自己独特的进程管理模块，这个模块有更强的可定制性，可根据“oom_adj”值的范围来决定进程管理策略，比如可以设定“当内存小于X时，结束“oom_adj”大于Y的进程”。这给了进程管理脚本的编写以更多的选择。 Android将进程分为六大类： 前台进程(foreground)：目前正在屏幕上显示的进程和一些系统进程。举例来说，Dialer Storage，Google Search等系统进程就是前台进程;再举例来说，当你运行一个程序，如浏览器，当浏览器界面在前台显示时，浏览器属于前台进程(foreground)，但一旦你按home回到主界面，浏览器就变成了后台程序(background)。我们最不希望终止的进程就是前台进程。
Android减少内存与内存泄露 Java编程中经常容易被忽视，但本身又十分重要的一个问题就是内存使用的问题。Android应用主要使用Java 语言编写，因此这个问题也同样会在Android开发中出现。Android主要应用在嵌入式设备当中，而嵌入式设备由于一些众所周知的条件限制，通常都不会有很高的配置，特别是内存是比较有限的。如果我们编写的代码当中有太多的对内存使用不当的地方，难免会使得我们的设备运行缓慢，甚至是死机。为了能够使得Android应用程序安全且快速的运行，Android的每个应用程序都会使用一个专有的Dalvik虚拟机实例来运行，它是由Zygote服务进程孵化出来的，也就是说每个应用程序都是在属于自己的进程中运行的。一方面，如果程序在运行过程中出现了内存泄漏的问题，仅仅会使得自己的进程被kill掉，而不会影响其他进程（如果是system_process 等系统进程出问题的话，则会引起系统重启）。另一方面Android为不同类型的进程分配了不同的内存使用上限，如果应用进程使用的内存超过了这个上限，则会被系统视为内存泄漏，从而被kill掉。 然而内存的消耗甚至泄露是不可避免的，那么首先只有养成良好的编程习惯，尽量做到减少内存的使用，尽可能的使垃圾内存得到回收，这才是解决问题的根本途径，那么我们该怎样编写代码呢？以下是本人的一些拙见以及网上达人们得一点点小小的建议： (一) 查询数据库没有关闭游标 程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。我觉得可以这样做： 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) 方法。
Android 图片加载性能优化总结 一、Android Bitmap加载大尺寸图片优化： 压缩原因： 1.imageview大小如果是200*300那么加载个2000*3000的图片到内存中显然是浪费可耻滴行为; 2.最重要的是图片过大时直接加载原图会造成OOM异常(out of memory内存溢出) 所以一般对于大图我们需要进行下压缩处理 看不懂英文的话木有关系,本篇会有介绍 主要处理思路是: 1.获取图片的像素宽高(不加载图片至内存中,所以不会占用资源) 2.计算需要压缩的比例 3.按将图片用计算出的比例压缩,并加载至内存中使用 官网大图片加载教程(上面网址里的)对应代码就是: /** * 获取压缩后的图片 * @param res * @param resId * @param reqWidth 所需图片压缩尺寸最小宽度 * @param reqHeight 所需图片压缩尺寸最小高度 * @return */ public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId, int reqWidth, int reqHeight) {
// 首先不加载图片,仅获取图片尺寸 final BitmapFactory.Options options = new BitmapFactory.Options(); // 当inJustDecodeBounds设为true时,不会加载图片仅获取图片尺寸信息 options.inJustDecodeBounds = true; // 此时仅会将图片信息会保存至options对象内,decode方法不会返回bitmap 对象 BitmapFactory.decodeResource(res, resId, options); // 计算压缩比例,如inSampleSize=4时,图片会压缩成原图的1/4 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); // 当inJustDecodeBounds设为false时,BitmapFactory.decode...就会返回图片对象了 options.inJustDecodeBounds = false; // 利用计算的比例值获取压缩后的图片对象 return BitmapFactory.decodeResource(res, resId, options); } 代码详解: 核心方法是BitmapFactory.decode...(...., options) ...的意思是此外还有一系列的decodeFile/decodeStream等等方法,都是利用options灵活解析获取图片, 只不过解析图片的来源不同罢了,比如网络图片获取,一般就是解析字节流信息然后decode获取图片实例 Options是图片配置信息,参数详细介绍下: inJustDecodeBounds 是否只解析边界 设为true时去decode获取图片,只会加载像素宽高信息 设为false时decode则会完全加载图片 inSampleSize 压缩比例
有Android手机的童鞋们可能经常会有这样的疑问，为什么我的G2手机明明是256M的内存，可用任务管理器或者free之类的命令，看到的实际值会远远小于256。看到网上的很多误导言论，这里我给大家澄清一下吧： 无图无真相，贴张MSM7627的内存分布图，一目了然： 由上图可以看到，内存主要分给modem/bootloader/SMEM/pmem/Android几个部分使用： 1、modem/bootloader/SMEM部分一般会占用40M~50M的内存，上图占用了43M。这部分主要用于跑AMSS、bootloader及RPC。如果你有源码的话，可以在 device\qcom\msmxxx/Boardconfig.mk看到。还有一种方法，可以用adb pull /proc/config.gz .将config.gz文件dump下来，里面可以看到分配给linux的内存大小，用物理内存总大小减去这部分，就可以得到这部分的内存总开销。 2、Pmem一般会占用40M的内存，上图占用了38M左右。系统的framebuffer\mdp\video 等都会用到这部分memory。如果你有源码的话，可以在
kernel/arch/arm/mach-msm/Board-xxx.c文件中看到Pmem的分配情况。譬如：#define MSM_PMEM_MDP_SIZE 0x1B76000 #define MSM_PMEM_ADSP_SIZE 0xAE4000 #define MSM_PMEM_AUDIO_SIZE 0x5B000 #define MSM_FB_SIZE 0x177000 #define MSM_GPU_PHYS_SIZE 0x177000 #define PMEM_KERNEL_EBI1_SIZE 0x1C000 3、最后是给用户空间使用的memory，用free或者cat /proc/meminfo等命令看到的是这部分的memory大小。大小是之前第一步传给linux kernel的memory大小减去pmem的占用部分再减去linux kernel和ramdisk大小。 本篇文章来源于Linux公社网站(https://www.doczj.com/doc/b612121967.html,) 原文链接： https://www.doczj.com/doc/b612121967.html,/Linux/2010-11/29891.htm
Java 和Android 内存优化的两个类:SoftReference 和WeakReference Posted on 2010-10-22 00:55 charley_yang阅读(436) 评论(0)编辑收藏 如果你想写一个Java 程序，观察某对象什么时候会被垃圾收集的执行绪清除，你必须要用一个reference 记住此对象，以便随时观察，但是却因此造成此对象的reference 数目一直无法为零，使得对象无法被清除。 view sourceprint? https://www.doczj.com/doc/b612121967.html,ng.ref.WeakReference 不过，现在有了Weak Reference 之后，这就可以迎刃而解了。如果你希望能随时取得某对象的信息，但又不想影响此对象的垃圾收集，那么你应该用Weak Reference 来记住此对象，而不是用一般的reference。 view sourceprint? 01 A obj = new A(); 02 03 WeakReference wr = new WeakReference(obj); 04 05 obj = null; 06 07 //等待一段时间，obj对象就会被垃圾回收 08... 09 10if(wr.get()==null) { 11System.out.println("obj 已经被清除了 "); 12} else{ 13System.out.println("obj 尚未被清除，其信息是 "+obj.toString()); 14} 15... 在此例中，透过get() 可以取得此Reference 的所指到的对象，如果传出值为null 的话，代表此对象已经被清除。 这类的技巧，在设计Optimizer 或Debugger 这类的程序时常会用到，因为这类程序需要取得某对象的信息，但是不可以影响此对象的垃圾收集。 https://www.doczj.com/doc/b612121967.html,ng.ref.SoftReference Soft Reference 虽然和Weak Reference 很类似，但是用途却不同。被Soft Reference 指到的对象，即使没有任何Direct Reference，也不会被清除。一直要到JVM 内存不足时且没有Direct Reference 时才会清除，SoftReference 是用来设计object-cache 之用的。如此一来SoftReference 不但可以把对象cache 起来，也不会造成内存不足的错误（OutOfMemoryError）。我觉得Soft Reference 也适合拿来实作pooling 的技巧。 view sourceprint? 01A obj = new A();
Android内存优化详解 Android内存泄露 前言 不少人认为JAVA程序，因为有垃圾回收机制，应该没有内存泄露。 其实如果我们一个程序中，已经不再使用某个对象，但是因为仍然有引用指向它，垃圾回收器就无法回收它，当然该对象占用的内存就无法被使用，这就造成了内存泄露。如果我们的java运行很久,而这种内存泄露不断的发生，最后就没内存可用了。当然java的，内存泄漏和C/C++是不一样的。如果java程序完全结束后，它所有的对象就都不可达了，系统就可以对他们进行垃圾回收，它的内存泄露仅仅限于它本身，而不会影响整个系统的。C/C++的内存泄露就比较糟糕了，它的内存泄露是系统级，即使该C/C++程序退出，它的泄露的内存也无法被系统回收，永远不可用了，除非重启机器。 Android的一个应用程序的内存泄露对别的应用程序影响不大。为了能够使得Android应用程序安全且快速的运行，Android的每个应用程序都会使用一个专有的Dalvik虚拟机实例来运行，它是由Zygote服务进程孵化出来的，也就是说每个应用程序都是在属于自己的进程中运行的。Android为不同类型的进程分配了不同的内存使用上限，如果程序在运行过程中出现了内存泄漏的而造成应用进程使用的内存超过了这个上限，则会被系统视为内存泄漏，从而被kill掉，这使得仅仅自己的进程被kill掉，而不会影响其他进程（如果是 system_process等系统进程出问题的话，则会引起系统重启）。 1,引用没释放造成的内存泄露 1.1注册没取消造成的内存泄露 这种Android的内存泄露比纯java的内存泄露还要严重，因为其他一些Android程序可能引用我们的Anroid程序的对象（比如注册机制）。即使我们的Android程序已经结束了，但是别的引用程序仍然还有对我们的Android程序的某个对象的引用，泄露的内存依然不能被垃圾回收。 比如示例1: 假设我们希望在锁屏界面(LockScreen)中，监听系统中的电话服务以获取一些信息(如信号强度等)，则可以在LockScreen中定义一个PhoneStateListener的对象，同时将它注册到TelephonyManager服务中。对于LockScreen对象，当需要显示锁屏界面的时候就会创建一个LockScreen对象，而当锁屏界面消失的时候LockScreen对象就会被释放掉。 但是如果在释放LockScreen对象的时候忘记取消我们之前注册的PhoneStateListener 对象，则会导致LockScreen无法被垃圾回收。如果不断的使锁屏界面显示和消失，则最终会由于大量的LockScreen对象没有办法被回收而引起OutOfMemory,使得 system_process进程挂掉。
优化的原因 用户体验 用户体验 用户体验 用户体验 …… 几个概念 线程安全：非UI线程不能更新UI组件 Android的进程与线程（3）线程安全问题 https://www.doczj.com/doc/b612121967.html,/yaolingrui/article/details/7420074帧率 优化原则 不要堵塞UI线程 开启新的线程去做复杂处理，在UI线程更新界面； getView()、onDraw()、scroll类的方法等运行要简洁快速
更简单地布局：少嵌套、适当使用权重布局和相对布局 Adapter优化：重用View和避免findViewById()
避免显示的布局里重复使用同一个背景 不显示的View，就隐藏不显示 在有些情况下Activity的背景可以设置为空getWindow().setBackgroundDrawable (null); android:windowBackground="@null"
纯色的背景比图片背景更高效 美术资源要求： 纯色的背景，只需提供背景的颜色值； 纹理背景尽量提供尽量小的一小块图片，而开发人员会根据这个 可以拉伸的背景，尽量提供尽量小的一小块图片，而开发人员会根据这个小图片拉伸背景。 需要进行矢量拉伸的图片要做.9.png格式处理。 android UI性能优化 https://www.doczj.com/doc/b612121967.html,/androidzhaoxiaogang/article/details/8673654 Android UI 优化 https://www.doczj.com/doc/b612121967.html,/view/02e26b4ce518964bcf847c04.html
目录 1引言 (1) 1.1编写目的 (1) 2DALVIK虚拟机初识 (1) 2.1D ALVIK优势： (1) 2.2基于栈与基于寄存器比较 (1) 2.3DEX文件格式 (3) 2.4ODEX文件格式 (3) 3内存分配跟踪工具DDMS–>ALLOCATION TRACKER 使用 (6) 4内存监测工具DDMS-->HEAP (6) 5内存分析工具MAT(MEMORYANALYZERTOOL) (8) 5.1生成.HPROF文件 (8) 5.2使用MAT导入.HPROF文件 (9) 5.3使用MAT的视图工具分析内存 (9) 6内存分配跟踪器（ALLOCATION TRACKER） (9) 7MAT使用实例 (10) 7.1生成HEAP DUMP (11) 7.2用MAT分析HEAP DUMPS (13) 7.3使用MAT比较HEAP DUMPS (14) 8常见内存使用不当情况 (14) 8.1查询数据库没有关闭游标 (15) 8.2构造A DAPTER时，没有使用缓存CONVERT V IEW (16) 8.3B ITMAP对象不在使用时调用RECYCLE()释放内存 (17) 8.4释放对象的引用 (17) 8.5C ONTEXT的使用 (19) 8.6线程 (21) 8.7单例模式导致内存泄露 (24) 8.8循环变量使用不当 (24) 8.9图片处理 (25)
8.10图片拉伸 (27) 8.11优化D ALVIK虚拟机的堆内存分配 (28) 8.12其他 (28) 9优化代码 (28) 9.1使用自身方法（U SE N ATIVE M ETHODS） (28) 9.2使用虚拟优于使用接口 (29) 9.3使用静态优于使用虚拟 (29) 9.4尽可能避免使用内在的G ET、S ET方法 (29) 9.5缓冲属性调用C ACHE F IELD L OOKUPS (29) 9.6声明F INAL常量 (30) 9.7慎重使用增强型F OR循环语句 (31) 9.8避免列举类型A VOID E NUMS (32) 9.9通过内联类使用包空间 (32) 9.10避免浮点类型的使用 (33) 9.11一些标准操作的时间比较 (34) 9.12为响应灵敏性设计 (34)
大家好，今天我主要来和大家交流下低端android手机内存优化的问题。 一、问题的引出 前天，我在论坛发了一个帖子，想请教大家关于联想A68e内存优 化的问题，但是回复者寥寥无几，课件也很少有机油对这方面有较深 入的学习了解。我今天中午，查了有关资料，也用了自己的手机进行 了测试，觉得可能对A68e（其实是广大低端Android手机）用户有点帮助，所以特地来分享以下。（说明：本人用的是Sumsumg I9103，我媳妇用的是电信套餐的联想A68e，这几天我没拿到她的手机来测试，所以只能自己的手机进行测试，但是我觉得还是具有一定的参考价值的）。 二、ROM和RAM 首先，我先解释一下ROM和RAM的区别。 ROM是Read Only Memory，即只读存储器；RAM是Access Random Memory，即随即读写存储器。 ROM是存储程序和数据的，类别电脑的硬盘，可以存放安装的程序、文件、数据等。而论坛中有开AppEXT2的方法（我没试过），那个只 是节省出更多的ROM空间，这样可以使程序运行得更为流畅，但是不 能解决“同时运行程序的数量最大值太小”的问题。以A68e为例，如果开一个QQ、音乐播放器，再开个UC浏览器估计机子就崩溃而导致程序退出。
RAM才是程序运行时所占用的物理空间。RAM的价格比ROM贵很多，所以RAM的大小一半程度上决定了机子的价位（另一半就是CPU）。我的Sumsung是1G RAM，同时开QQ、QQ游戏、QQ音乐、浏览器、微信等七、八个程序也毫无压力。所以RAM太小是影响A68e（包括很多Android手机）用户体验的原因。如果你是个游戏玩家、手机达人，那么这类机子一定不适合你。如果你希望能像有高端机那样的用户体验，我建议你还是多话点银子购买配置高的Android手机。 关于官方宣传256的RAM实际上只有170，那是有一部分被Android系统占用。我的手机1GRAM，实际上也只有724M。 三、Android系统内存管理机制及进程调度机制 下面开始具体的分析了。 首先Android系统是基于Linux 内核开发的开源操作系统，linux 系统的内存管理有其独特的动态存储管理机制。Android采取了一种有别于Linux的进程管理策略，Linux系统在进程活动停止后就结束该进程，而Android把这些进程都保留在内存中，直到系统需要更多内存为止。这些保留在内存中的进程通常情况下不会影响整体系统的运行速度，并且当用户再次激活这些进程时，提升了进程的启动速度。 Android系统这样的设计不仅非常适合移动终端（手机、平板）的需要，而且减少了系统崩溃的可能，确保了系统的稳定性。老想着清理内存的同学完全是因为被塞班或者Windows毒害太深，事实上，经常用Taskiller之类的软件关闭后台所有进程，很容易造成系统的不稳定。很多时候出现问题了，只要重启就能解决的原因也在于此。