1-Android开发知识Android DevAndroid知识

菜鸡向高手进阶--内存优化

2017-04-06  本文已影响723人  甜甜的清风啊

Android 设备作为一种移动设备，不管是内存还是 CPU 的性能都受到了一定的限制，无法做到象 PC 设备那样具有超大的内存和高性能的 CPU。谷歌对 Android 系统的每个 app 做了内存限制，不同版本的 android 系统，不同的设备对每个 app 的内存限制可能有所不同，从早期的 16M , 32M 到现在的 256M , 384M ...，虽然内存越来越大，但是终归是有限制的，这也意味着 Android 程序不可能无限制地使用内存和 CPU 资源，过多地使用内存会导致程序内存溢出，即 OOM（Out Of Memory）。而过多地使用 CPU 资源，一般是指做大量地耗时任务，会导致手机变得卡顿甚至出现程序无法响应的情况，即 ANR（Application Not Response）。

这篇文章主要讲解内存优化。

小知识扩展

先提几个以前一直弄的很混的高频词汇：** 内存 外存 运存 ROM RAM **

手机储存（像我的红米 note 2 就是 8G “内存”）指手机本自身带的储存空间。这个空间是用来存放文件的，像音乐文件，图片文件，文本文件等等。这个相当于你插的内存卡（不过现在大多都是一体机，不支持外部扩展内存了。），只不过是这个内存卡是直接“粘”在你手机内的。不能像内存卡那样可以拆下来作它用。这里说的全是外存。

我们常说的运存就是指内存（我的红米 note 2 就是 2G 内存）（在电脑计算机术语里，运存就直接称为内存，但是在手机上我们常说内存卡的内存有多大，这个内存实际指的不是运行内存，而是指这个内存卡的容量，和上面的手机储存是一样的，可以统称为外存。只不过内存卡可以拆下来），这也是手机的储存空间，这个是随机储存器，英文 ram，不能像上面说的手机储存那样断电后存放的东西不会消失，放在这里面的东西你的手机重启后就会没有了。当然用户是不能存放东西在这里面的。

你不能对这一块的内存进行操作。比如你要运行一个程序，你打开程序后，手机会把要和这个要运行的程序的相关数据资料调入内存。然后在内存里运行这个程序。之所以要这么做而不直接在外存里运行是因为内存读写速度比外存外很多，这样表现在用户面前就是手机的反应很快，用户体验高。缓存也是内存的一种，缓存的速度要比一般的内存快，所以里面存放的东西都是 cpu 在运行时频繁用到的数据。在手机上很少提到缓存这个概念，就算说到这个多数也指是的手机里的缓存文件。上面已经说到了一点，手机的运行速度和内存有关，还和 cpu 的处理速度有关。

可能大家常常会看到 ** RAM 和 ROM **，这里给大家详细解释下它们的区别。存储器分为随机存储器（RAM Random Access Memory）和只读存储器（ROM Read Only Memory）两种。其中 ROM 通常用来固化存储一些生产厂家写入的程序或数据，用于启动电脑和控制电脑的工作方式，手机上这个也就是放固件的，系统。而 RAM 则用来存取各种动态的输入输出数据、中间计算结果以及与外部存储器交换的数据和暂存数据。设备断电后， RAM 中存储的数据就会丢失。上面也解释了，这个就是常说的运存。

对于手机而言 运行游戏、程序速度快慢看的是的是 RAM，也就是动态内存，不是看 ROM 。ROM 是静态空间，用来存储东西的，相当于手机的 C 盘。 RAM 和 ROM 就好比是电脑的内存和硬盘。C 盘准确的来讲也不应该叫 ROM 只读存储器。C 盘应该叫FLASH ROM（不是 FLASH 动画，呵呵）是 ROM 的进化，可以反复写而且速度快。

一般手机自带储存、U 盘、MP3 都是这个（通过这个也可以知道为什么U盘比内存卡贵很多），因为 C 盘是可擦写的，而 FLASH 的大小并不影响运行速度。

一、Android 内存管理原理

Android 系统的内存管理原理

Android 系统内核是基于 Linux 。 Android 把这些停止的进程都保留在内存中，直到系统需要更多内存时才选择性的释放一些，保留在内存中的进程默认不会影响整体系统的性能（速度与电量等）且当再次启动这些保留在内存的进程时可以明显提高启动速度，不需要再去加载。

应用级内存管理

二、常见内存问题

内存泄露

1.内存泄漏的概念

我的理解：内存泄漏就像东西丢了一样，这个东西（这块内存）你也就没法使用了。
官方概念：内存泄露就是一个对象被超过自己生命周期以外的对象强引用导致该对象无法被正常垃圾回收。

2.内存泄漏的危害

我的理解：东西丢了，首先很伤心。然后你这东西总共就几个（手机内存只有这么大），你丢了一个就少一个，丢着丢着就全没了，干不成需要用它的其它事情了，伤心欲绝。

危害：

3.常见的内存泄漏

private static Context sContext;
    private static View sView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // static variable sContext reference activity instance,
        // make activity instance not destroy
        sContext = this;
        sView = new View(this);
    }

package com.example.memoryleak;
import java.util.ArrayList;
import java.util.List;
public class TestManager {
    private List<OnDataArrivedListener> mOnDataArrivedListeners = new ArrayList<OnDataArrivedListener>();

    private static class SingletonHolder {
        public static final TestManager INSTANCE = new TestManager();
    }

    private TestManager() {
    }

    public static TestManager getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public synchronized void registerListener(OnDataArrivedListener listener) {
        if (!mOnDataArrivedListeners.contains(listener)) {
            mOnDataArrivedListeners.add(listener);
        }
    }

    public synchronized void unregisterListener(OnDataArrivedListener listener) {
        mOnDataArrivedListeners.remove(listener);
    }

    public interface OnDataArrivedListener {
        public void onDataArrived(Object data);
    }
}

接着在 Activity 中实现 OnDataArrivedListener 接口并向 TestManager 注册监听，但是由于缺少解除注册的的操作所以会引起内存泄漏，原因时 Activity 的对象被单例模式的 TestManager 所持有，而单利模式的特点就是其生命周期和 Application 保持一直，因此 Activity 对象无法被及时释放。

package com.example.memoryleak;
import android.content.Context;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
public class MainActivity extends AppCompatActivity implements TestManager.OnDataArrivedListener {
    private static Context sContext;
    private static View sView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TestManager.getInstance().registerListener(this);
    }

    @Override
    public void onDataArrived(Object data) {

    }
}

  TextView textView = (TextView) findViewById(R.id.text);
        ObjectAnimator animator = ObjectAnimator.ofFloat(textView, "rotation", 0, 360)
                .setDuration(2000);
        animator.setRepeatCount(ValueAnimator.INFINITE);
        animator.start();
        // animator.cancel();

public class Utils {
    private static Utils mInstance;
    private static Context mContext;
    public static Utils getInstance(Context context){
        if (mInstance == null) {
            synchronized (Utils.class) {
                if (mInstance == null) {
                    mInstance=new Utils();
                }
            }
        }
        mContext=context;
        return mInstance;
    }
    public void setTextView(TextView textView) {
        textView.setText(mContext.getResources().getString(R.string.hell_android));
    }
    public static void release() {
        mContext=null;
        mInstance=null;
    }

}

Activity 中要在 onDestory() 方法中释放工具类对 Activity 实例的引用。

public class MainActivity extends AppCompatActivity {
    Double[] mDoubles = new Double[10_000_000];
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void onClick(View view) {
        TextView textView= (TextView) findViewById(R.id.tv);
        Utils.getInstance(this).setTextView(textView);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Utils.release();
    }
}

public class MainActivity extends AppCompatActivity {
    Double[] mDoubles = new Double[10_000_000];

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void onClick(View view) {
        InnerClass innerClass = new InnerClass();
        innerClass.work();
        finish();
    }

    class InnerClass {
        public void work() {
            new Thread(){
                @Override
                public void run() {
                    while (true) {
                        SystemClock.sleep(1000);
                        Log.i("main", "work...");
                    }
                }
            }.start();
        }
    }
}

如何检测内存泄漏

如何避免内存泄漏

1、减少静态变量对Activity、Application的引用
2、及时手动释放静态变量引用的对象
3、Activity内部类在Activity销毁时，要及时停止运行
4、Activity使用静态内部类并使用WeakReference引用

内存抖动

内存抖动的概念

内存抖动（Memory Churn）：在短时间内大量对象被创建又马上被销毁。原因是瞬间产生大量的对象会严重占用 Young Generation 的内存区域，当达到阈值，剩余空间不够的时候，会触发 GC 从而导致刚创建的对象又马上被回收。即使创建的对象占用了很少的内存，但是数量多了时会增加 heap 的压力，从而触发更多其他类型的 GC。这个操作有可能会影响到帧率，并使得用户感知到性能问题。

内存抖动如何检测

public void memoryChurn(View view) {
        String str = new String();
        for(int i=1;i<=10_000_000;i++) {
            str += "abc";
        }
    }

如何避免内存抖动

避免在循环、onDraw、getView或onBindViewHolder等方法中执行重复创建对象的操作。

内存溢出

内存溢出的概念

Android 的应用程序所能申请的最大内存都是有限的，内存溢出是指 APP 向系统申请内存的请求超出了系统为应用分配的阈值，系统无法在分配多余的空间，就会造成 OOM。

内存溢出的两种情况

1、内存泄漏（Memory Leak），累计到一定程度导致 OOM。
2、一次性申请很多内存。

如何避免内存溢出

1、避免内存泄露。
2、用try/catch捕获处理OOM异常，避免OOM导致的崩溃。

上一篇 下一篇

猜你喜欢

热点阅读