Android_冯星
Android_冯星

Android性能优化

Android的性能优化，主要是从以下几个方面进行优化的： 稳定（内存溢出、崩溃） 流畅（卡顿） 耗损（耗电、流量） 安装包（APK瘦身） 影响稳定性的原因很多，比如内存使用不合理、代码异常场景考虑不周全、代码逻辑不合理等，都会对应用的稳定性造成影响。其中最常见的两个场景是：Crash 和 ANR，这两个错误将会使得程序无法使用。所以做好Crash全局监控，处理闪退同时把崩溃信息、异常信息收集记录起来，以便后续分析;合理使用主线程处理业务，不要在主线程中做耗时操作，防止ANR程序无响应发生。

内存是Android运行性能至关重要的一项指标，每个进程能使用的内存是有限的。不合理的使用内存会导致频繁的GC、甚至发生OOM，过多GC会导致App卡顿，而内存泄漏或者内存抖动都可以导致OOM，这是无法接受的。

Android性能优化_第1张图片
image.png
总结一下几点

......

  1. 如果父控件有颜色，也是自己需要的颜色，那么就不必在子控件加背景颜色
  2. 如果每个自控件的颜色不太一样，而且可以完全覆盖父控件，那么就不需要再父控件上加背景颜色
  3. 尽量减少不必要的嵌套
  4. 能用LinearLayout和FrameLayout，就不要用RelativeLayout，因为RelativeLayout控件相对比较复杂，测绘也想要耗时。
  5. 使用include和merge增加复用，减少层级
  6. ViewStub按需加载，更加轻便
  7. 复杂界面可选择ConstraintLayout，可有效减少层级
  8. onDraw中不要创建新的局部对象
  9. onDraw方法中不要做耗时的任务
  10. 解决各个情况下的内存泄漏，注意平时代码的规范。
  11. 利用提前展示出来的Window，快速展示出来一个界面，给用户快速反馈的体验；
  12. 避免在启动时做密集沉重的初始化（Heavy app initialization）；
  13. 避免I/O操作、反序列化、网络操作、布局嵌套等。
  14. 代码混淆
  15. 插件化
  16. 资源优化
  17. 使用JobScheduler调度任务
  18. 使用懒惰法则
  19. ListView使用ViewHolder，分段，分页加载
  20. 压缩Bitmap
  21. 使用线程池优化线程
  22. 避免在主线程中做耗时操作

稳定（内存溢出，崩溃）

内存泄露

通俗来讲，内存泄露不仅仅会造成应用内存占用过大，还会导致应用卡顿，造成不好的用户体验。

Android性能优化_第2张图片
image.png

这就是Android开发童鞋需要了解的Generational Heap Memory模型，这里我们只关心当对象在Young Generation中存活了一段时间之后，如果没被干掉，那么会被移动到Old Generation中，同理，最后会移动到Permanent Generation中。那么用脚想一想就知道，如果内存泄露了，那么，抱歉，你那块内存随时间推移自然而然将进入Permanent Generation中，然鹅，内存不是白菜，想要多少就有多少，这里，因为沙盒机制的原因，分配给你应用的内存当然是有那么一个极限值的，你不能逾越（有人笑了，不是有large heap么，当然我也笑了，我并没有看到这货被宗师android玩家青睐过），好了，你那块造成泄露内存的对象占着茅坑不拉屎，剩下来可以供其他对象发挥的内存空间就少了；打个比方，舞台小了，演员要登台表演，没有多余空间，他就只能等待其他演员下来他才能表演啊，这等待的时间，是没法连续表演的，所以就卡了嘛。

频繁GC

什么时候会导致频繁GC

  • 内存抖动
    短时间内创建了大量对象同时又被快速释放。比如在一个大循环里去不断创建对象，会导致频繁gc;

  • 内存泄漏
    内存泄漏会导致可用内存逐渐变少，而且内存碎片加多，这也会增多gc次数，甚至可能发生OOM

  • 一次申请太大内存空间
    由于内存碎片的存在，就算内存本身足够，但由于碎片导致无法找到一块大空间，这也会触发gc；

OOM问题

  • 内存泄漏了

  • 大量不可见的对象占据内存，这个其实，很常见，只是大家可能一直不太关心罢了，比如，请求接口返回了列表有100项数据，每项数据比如有100个字段，其中你用户展示数据的只有10几个而已，但是，你解析的时候，剩下的99个不知不觉吃了你的内存，当，有个胖子要内存时，呵呵，嗝屁了

  • 还有一种很常见的场景是一个页面多图的场景，明明每个图只需要加载一个100100的，你却使用原始尺寸（10801980）or更大，而且你一下子还加载个几十张，扛得住么？所以了解一下inSampleSize，或者，如果图片归你们上传管理，你可以借助万象优图，他为你做了剪切好不同尺寸的图片，这样省得你在客户端做图片缩放了

内存泄露

内存泄漏指的是那些程序不再使用的对象无法被GC识别，这样就导致这个对象一直留在内存当中，占用了没来就不多的内存空间。

那么什么情况下会出现这样的对象呢？ 基本可以分为以下四大类：
1、集合类泄漏
2、单例/静态变量造成的内存泄漏
3、匿名内部类/非静态内部类
4、资源未关闭造成的内存泄漏

集合类泄漏

集合类添加元素后，仍引用着集合元素对象，导致该集合中的元素对象无法被回收，从而导致内存泄露。

static List mList = new ArrayList<>();
   for (int i = 0; i < 100; i++) {
       Object obj = new Object();
      mList.add(obj);
       obj = null;
    }

 
 
当mList没用的时候，我们如果不做处理的话，这就是典型的占着茅坑不拉屎，mList内部持有者众多集合元素的对象，不泄露天理难容啊。解决这个问题也超级简单。把mList清理掉，然后把它的引用也给释放掉。
 
 
  mList.clear();
  mList = null;

 
 
单例模式具有其 静态特性，它的生命周期 等于应用程序的生命周期，正是因为这一点，往往很容易造成内存泄漏。 先来一个小栗子：
 
 
public class SingleInstance {

    private static SingleInstance mInstance;
    private Context mContext;

    private SingleInstance(Context context){
        this.mContext = context;
    }

    public static SingleInstance newInstance(Context context){
        if(mInstance == null){
            mInstance = new SingleInstance(context);
        }
        return sInstance;
    }
}


 
 
单例/静态变量造成的内存泄漏
 
 
当我们在Activity里面使用这个的时候，把我们Acitivty的context传进去，那么，这个单例就持有这个Activity的引用，当这个Activity没有用了，需要销毁的时候，因为这个单例还持有Activity的引用，所以无法GC回收，所以就出现了内存泄漏，也就是生命周期长的持有了生命周期短的引用，造成了内存泄漏。
 
 
public class SingleInstance {

    private static SingleInstance mInstance;
    private Context mContext;

    private SingleInstance(Context context){
        this.mContext = context.getApplicationContext();
    }

    public static SingleInstance newInstance(Context context){
        if(mInstance == null){
            mInstance = new SingleInstance(context);
        }
        return sInstance;
    }
}


 
 
匿名内部类/非静态内部类
 
 
 
  
 
   
 
    Android性能优化_第3张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
非静态内部类他会持有他外部类的引用，从图我们可以看到非静态内部类的生命周期可能比外部类更长，这就是二楼的情况一致了，如果非静态内部类的周明周期长于外部类，在加上自动持有外部类的强引用，我的乖乖，想不泄漏都难啊。
 
 
public class TestActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        new MyAscnyTask().execute();
    }

    class MyAscnyTask extends AsyncTask{
        @Override
        protected String doInBackground(Void... params) {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "";
        }
    }
}


 
 
我们经常会用这个方法去异步加载，然后更新数据。貌似很平常，我们开始学这个的时候就是这么写的，没发现有问题啊，但是你这么想一想，MyAscnyTask是一个非静态内部类，如果他处理数据的时间很长，极端点我们用sleep 100秒，在这期间Activity可能早就关闭了，本来Activity的内存应该被回收的，但是我们知道非静态内部类会持有外部类的引用，所以Activity也需要陪着非静态内部类MyAscnyTask一起天荒地老。好了，内存泄漏就形成了。
 
 
既然MyAscnyTask的生命周期可能比较长，那就把它变成静态，和Application玩去吧，这样MyAscnyTask就不会再持有外部类的引用了。两者也相互独立了。
 
 
public class TestActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        new MyAscnyTask().execute();
    }
//改了这里 注意一下 static
   static  class MyAscnyTask extends AsyncTask{
        @Override
        protected String doInBackground(Void... params) {
            try {
                Thread.sleep(100000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "";
        }
    }
}

 
 
说完非静态内部类，我再来看看匿名内部类，这个问题很常见，匿名内部类和非静态内部类有一个共同的地方，就是会只有外部类的强引用，所以这哥俩本质是一样的。但是处理方法有些不一样。但是思路绝对一样。换汤不换药。
 
 
public class TestActivity extends Activity {
private TextView mText;
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
//do something
mText.setText(" do someThing");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
mText = findVIewById(R.id.mText);
        //  匿名线程持有 Activity 的引用，进行耗时操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    
        mHandler. sendEmptyMessageDelayed(0, 100000);
    }


 
 
想必这两个方法是我们经常用的吧，很熟悉，也是这么学的，没感觉不对啊，老师就是这么教的，通过我们上面的分析，还这么想吗？关键是 耗时时间过长，造成内部类的生命周期大于外部类，对弈非静态内部类，我们可以静态化，至于匿名内部类怎么办呢？一样把它变成静态内部类，也就是说尽量不要用匿名内部类。完事了吗？很多人不注意这么一件事，如果我们在handleMessage方法里进行UI的更新，这个Handler静态化了和Activity没啥关系了，但是比如这个mText，怎么说？全写是activity.mText，看到了吧，持有了Activity的引用，也就是说Handler费劲心思变成静态类，自认为不持有Activity的引用了，准确的说是不自动持有Activity的引用了，但是我们要做UI更新的时候势必会持有Activity的引用，静态类持有非静态类的引用，我们发现怎么又开始内存泄漏了呢？处处是坑啊，怎么办呢？我们这里就要引出弱引用的概念了。
 
 
引用分为强引用，软引用，弱引用，虚引用，强度依次递减。
 
 
     
  
  • 强引用
     我们平时不做特殊处理的一般都是强引用，如果一个对象具有强引用，GC宁可OOM也绝不会回收它。看出多强硬了吧。
    •  
  
  • 软引用(SoftReference)
     如果内存空间足够，GC就不会回收它，如果内存空间不足了，就会回收这些对象的内存。
    •  
  
  • 弱引用（WeakReference）
     弱引用要比软引用,更弱一个级别，内存不够要回收他，GC的时候不管内存够不够也要回收他，简直是弱的一匹。不过GC是一个优先级很低的线程，也不是太频繁进行，所以弱引用的生活还过得去，没那么提心吊胆。
    •  
  
  • 虚引用
     用的甚少，我没有用过，如果想了解的朋友，可以自行谷歌百度。
    •  
 
 
 
所以我们用弱引用来修饰Activity，这样GC的时候，该回收的也就回收了，不会再有内存泄漏了。很完美。
 
 
public class TestActivity extends Activity {
    private TextView mText;
    private MyHandler myHandler = new MyHandler(TestActivity.this);
    private MyThread myThread = new MyThread();

    private static class MyHandler extends Handler {

        WeakReference weakReference;

        MyHandler(TestActivity testActivity) {
            this.weakReference = new WeakReference(testActivity);

        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            weakReference.get().mText.setText("do someThing");

        }
    }

    private static class MyThread extends Thread {

        @Override
        public void run() {
            super.run();

            try {
                sleep(100000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        mText = findViewById(R.id.mText);
        myHandler.sendEmptyMessageDelayed(0, 100000);
        myThread.start();
    }
//最后清空这些回调 
    @Override
    protected void onDestroy() {
        super.onDestroy();
        myHandler.removeCallbacksAndMessages(null);
    }


 
 
资源未关闭造成的内存泄漏
 
 
     
  
  • 网络、文件等流忘记关闭
    •  
  
  • 手动注册广播时，退出时忘记 unregisterReceiver()
    •  
  
  • Service 执行完后忘记 stopSelf()
    •  
  
  • EventBus 等观察者模式的框架忘记手动解除注册
    •  
 
 
 
工具
 
 
1、leakcanary傻瓜式操作，哪里有泄漏自动给你显示出来，很直接很暴力。
 
 
2、我们平时也要多使用Memory Monitor进行内存监控，这个分析就有些难度了，可以上网搜一下具体怎么使用。
 
 
3、Android Lint 它可以帮助我们发现代码机构 / 质量问题，同时提供一些解决方案，内存泄露的会飘黄，用起来很方便，具体使用方法上网学习，这里不多做说明了。
 
 
LeakCanary
 
 
LeakCanary提供了一种很方便的方式，让我们在开发阶段测试内存泄露，我们不需要自己根据内存块来分析内存泄露的原因，我们只需要在项目中集成他，然后他就会帮我们检测内存泄露，并给出内存泄露的引用链
 
 
 
  
通过监听Activity的onDestory，手动调用GC，然后通过ReferenceQueue+WeakReference，来判断Activity对象是否被回收，然后结合dump Heap的hpof文件，通过Haha开源库分析泄露的位置
 
 
 
 
LeakCanary主要的知识点
 
 
注册Activity的生命周期的监听器
 
 
通过Application.registerActivityLifecycleCallbacks()方法注册Activity的生命周期的监听器，每一个Activity的生命周期都会回调到这个ActivityLifecycleCallbacks上，如果一个Activity走到了onDestory，那么就意味着他就不再存在，然后检测这个Activity是否是真的被销毁
 
 
通过ReferenceQueue+WeakReference，来判断对象是否被回收
 
 
WeakReference创建时，可以传入一个ReferenceQueue对象，假如WeakReference中引用对象被回收，那么就会把WeakReference对象添加到ReferenceQueue中，可以通过ReferenceQueue中是否为空来判断，被引用对象是否被回收
 
 
快（流畅、卡顿）
 
 
 
  
 
   
 
    Android性能优化_第4张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
布局优化
 
 
屏幕上的某个像素在同一帧的时间内被绘制了多次。在多层次的UI结构里面，如果不可见的UI也在做绘制的操作，这就会导致某些像素区域被绘制了多次。这就浪费大量的CPU以及GPU资源。
 
 
     
  
  • 如果父控件有颜色，也是自己需要的颜色，那么就不必在子控件加背景颜色
    •  
  
  • 如果每个自控件的颜色不太一样，而且可以完全覆盖父控件，那么就不需要再父控件上加背景颜色
    •  
  
  • 尽量减少不必要的嵌套
    •  
  
  • 能用LinearLayout和FrameLayout，就不要用RelativeLayout，因为RelativeLayout控件相对比较复杂，测绘也想要耗时。
    •  
  
  • 使用include和merge增加复用，减少层级
    •  
  
  • ViewStub按需加载，更加轻便
    •  
  
  • 复杂界面可选择ConstraintLayout，可有效减少层级
    •  
 
 
 
绘制优化
 
 
我们平时感觉的卡顿问题最主要的原因之一是因为渲染性能，因为越来越复杂的界面交互，其中可能添加了动画，或者图片等等。我们希望创造出越来越炫的交互界面，同时也希望他可以流畅显示，但是往往卡顿就发生在这里。
 
 
这个是Android的渲染机制造成的，Android系统每隔16ms发出VSYNC信号，触发对UI进行渲染，但是渲染未必成功，如果成功了那么代表一切顺利，但是失败了可能就要延误时间，或者直接跳过去，给人视觉上的表现，就是要么卡了一会，要么跳帧。
 
 
View的绘制频率保证60fps是最佳的，这就要求每帧绘制时间不超过16ms(16ms = 1000/60)，虽然程序很难保证16ms这个时间，但是尽量降低onDraw方法中的复杂度总是切实有效的。
 
 
这个正常情况下，每隔16ms draw()一下，很整齐，很流畅，很完美。
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
往往会发生如下图的情况，有个便秘的家伙霸占着，一帧画面拉的时间那么长，这一下可不就卡顿了嘛。把后面的时间给占用了，后面只能延后，或者直接略过了。
 
 
 
  
 
   
 
    Android性能优化_第5张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
     
  
  • onDraw中不要创建新的局部对象
    •  
  
  • onDraw方法中不要做耗时的任务
    •  
 
 
 
启动速度优化
 
 
app启动分为冷启动（Cold start）、热启动（Hot start）和温启动（Warm start）三种。
 
 
冷启动
 
 
冷启动是指应用程序从头开始：系统的进程在此开始之前没有创建应用程序。冷启动发生在诸如自设备启动以来首次启动应用程序或自系统终止应用程序以来。
 
 
在冷启动开始时，系统有三个任务。这些任务是： 1、加载并启动应用程序 2、启动后立即显示应用程序的空白启动窗口 3、创建应用程序进程
 
 
当系统为我们创建了应用进程之后，开始创建应用程序对象。
 
 
1、启动主线程
 2、创建主Activity
 3、加载布局
 4、屏幕布局
 5、执行初始绘制
 
 
应用程序进程完成第一次绘制后，系统进程会交换当前显示的背景窗口，将其替换为主活动。此时，用户可以开始使用该应用程序。至此启动完成。
 
 
 
  
 
   
 
    Android性能优化_第6张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
Application创建
 
 
当Application启动时，空白的启动窗口将保留在屏幕上，直到系统首次完成绘制应用程序。此时，系统进程会交换应用程序的启动窗口，允许用户开始与应用程序进行交互。这就是为什么我们的程序启动时会先出现一段时间的黑屏(白屏)。
 
 
如果我们有自己的Application，系统会onCreate()在我们的Application对象上调用该方法。之后，应用程序会生成主线程（也称为UI线程），并通过创建主要活动来执行任务。
 
 
从这一点开始，App就按照他的 应用程序生命周期阶段进行。
 
 
Activity创建
 
 
应用程序进程创建活动后，活动将执行以下操作：
 
 
     
  
  1. 初始化值。
    2.  
  
  2. 调用构造函数。
    3.  
  
  3. 调用回调方法，例如 Activity.onCreate()，对应Activity的当前生命周期状态。
    4.  
 
 
 
通常，该 onCreate()方法对加载时间的影响最大，因为它以最高的开销执行工作：加载和膨胀视图，以及初始化活动运行所需的对象。
 
 
热启动
 
 
应用程序的热启动比冷启动要简单得多，开销也更低。在一个热启动中，系统都会把你的Activity带到前台。如果应用程序的Activity仍然驻留在内存中，那么应用程序可以避免重复对象初始化、布局加载和渲染。
 
 
热启动显示与冷启动方案相同的屏幕行为：系统进程显示空白屏幕，直到应用程序完成呈现活动。
 
 
温启动
 
 
温启动包含了冷启动时发生的一些操作，与此同时，它表示的开销比热启动少，有许多潜在的状态可以被认为是温暖的开始。
 
 
场景：
 
 
     
  
  • 用户退出您的应用，但随后重新启动它。该过程可能已继续运行，但应用程序必须通过调用从头开始重新创建Activity 的onCreate()。
    •  
  
  • 系统将您的应用程序从内存中逐出，然后用户重新启动它。需要重新启动进程和活动，但是在调用onCreate()的时候可以从Bundle（savedInstanceState）获取数据。
    •  
 
 
 
了解完启动过程，我们就知道哪里会影响我们启动的速度了。在创建应用程序和创建Activity期间都可能会出现性能问题。
 
 
这里是慢的定义：
 
 
     
  
  •  冷启动需要5秒或更长时间。
    •  
  
  •  温启动需要2秒或更长时间。
    •  
  
  •  热启动需要1.5秒或更长时间。
    •  
 
 
 
无论何种启动，我们的优化点都是： Application、Activity创建以及回调等过程
 
 
谷歌官方给的建议是：
 1、利用提前展示出来的Window，快速展示出来一个界面，给用户快速反馈的体验；
 2、避免在启动时做密集沉重的初始化（Heavy app initialization）；
 3、避免I/O操作、反序列化、网络操作、布局嵌套等。
 
 
具体做法：
 
 
针对1：利用提前展示出来的Window，快速展示出来一个界面
 
 
使用Activity的windowBackground主题属性来为启动的Activity提供一个简单的drawable。
 
 

  
  
  
  
    
  



 
 


 
 
这样在启动的时候，会先展示一个界面，这个界面就是Manifest中设置的Style，等Activity加载完毕后，再去加载Activity的界面，而在Activity的界面中，我们将主题重新设置为正常的主题，从而产生一种快的感觉。其实就是个障眼法而已，提前让你看到了假的界面。也算是一种不错的方法，但是治标不治本。
 
 
针对2：避免在启动时做密集沉重的初始化
 
 
我们审视一下我们的MyApplication里面的操作。初始化操作有友盟，百度，bugly，数据库，IM，神策，图片加载库，网络请求库，广告sdk，地图，推送，等等，这么多需要初始化，Application的任务太重了，启动不慢才怪呢。
 
 
怎么办呢？这些还都是必要的，不能不去初始化啊，那就只能异步加载了。但是并不是所有的都可以进行异步处理。这里分情况给出一些建议：
 
 
1、比如像友盟，bugly这样的业务非必要的可以的异步加载。
 
 
2、比如地图，推送等，非第一时间需要的可以在主线程做延时启动。当程序已经启动起来之后，在进行初始化。
 
 
3、对于图片，网络请求框架必须在主线程里初始化了。
 
 
同时因为我们一般会有闪屏页面，也可以把延时启动的地图，推动的启动在这个时间段里，这样合理安排时间片的使用。极大的提高了启动速度。
 
 
针对3：避免I/O操作、反序列化、网络操作、布局嵌套等。
 
 
1. GPU过度绘制，定位过度绘制区域
 
 
这里直接在开发者选项，打开Show GPU Overdraw，就可以看到效果，轻松发现哪块需要优化。
 
 
     
  
  • 减少布局层级
     使用ConstraintLayout替换传统的布局方式。
    •  
  
  • 检查是否有多余的背景色设置
    •  
 
 
 
 
  
我们通常会犯一些低级错误--对被覆盖的父view设置背景，多数情况下这些背景是没有必要的。
 
 
 
 
2. 主线程耗时操作排查
 
 
     
  
  • 开启strictmode,这样一来，主线程的耗时操作都将以告警的形式呈现到logcat当中
    •  
 
 
 
StrictMode，严苛模式，是Android提供的一种运行时检测机制，用于检测代码运行时的一些不规范的操作，最常见的场景是用于发现主线程的IO操作和网络读写等耗时的操作。
 
 
3. 对于measure，layout耗时过多的问题
 
 
一般这类问题是由于布局过于复杂的原因导致，现在因为有ConstraintLayout，所以，强烈建议使用ConstraintLayout减少布局层级，问题一般得以解决，如果发现还存在性能问题，可以使用traceView观察方法耗时，来定位下具体原因。
 
 
 
  
TraceView 是 Android SDK 内置的一个工具，它可以加载 trace 文件，用图形的形式展示代码的执行时间、次数及调用栈，便于我们分析。
 
 
 
 
4.
 
 
5. onDraw里面写代码需要注意
 
 
onDraw由于大概每16ms都会被执行一次，因此本身就相当于一个forloop，如果你在里面new对象的话，不知不觉中就满足了短时间内大量对象创建并释放，于是频繁GC就发生了，嗯，内存抖动，于是，卡了。因此，正确的做法是将对象放在外面new出来。
 
 
第一点： onDraw方法中不要做耗时的任务，也不做过多的循环操作，特别是嵌套循环，虽然每次循环耗时很小，但是大量的循环势必霸占CPU的时间片，从而造成View的绘制过程不流畅。
 
 
第二点： 除了循环之外，onDraw()中不要创建新的局部对象，因为onDraw()方法一般都会频繁大量调用，就意味着会产生大量的零时对象，不进占用过的内存，而且会导致系统更加频繁的GC，大大降低程序的执行速度和效率。
 
 
6. json反序列化问题
 
 
json反序列化是指将json字符串转变为对象，这里如果数据量比较多，特别是有相当多的string的时候，解析起来不仅耗时，而且还很吃内存。解决的方式是：
 
 
     
  
  • 精简字段，与后台协商，相关接口剔除不必要的字段。保证最小可用原则。
    •  
  
  • 使用流解析，之前我考虑过json解析优化，在Stack Overflow上搜索到这个。于是了解到Gson.fromJson是可以这样玩的，可以提升25%的解析效率。
    •  
 
 
 
 
  
 
   
 
    Android性能优化_第7张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
7.viewStub&merge&ViewStub的使用
 
 
这里merge和viewStub想必是大家非常了解的两个布局组件了，对于只有在某些条件下才展示出来的组件，建议使用viewStub包裹起来，同样的道理，include 某布局如果其根布局和引入他的父布局一致，建议使用merge包裹起来，如果你担心preview效果问题，这里完全没有必要，因为你可以tools:showIn=""属性，这样就可以正常展示preview了。
 
 
ViewStub它可以按需加载，什么意思？用到他的时候喊他一下，再来加载，不需要的时候像空气一样，在一边静静的呆着，不吃你的米，也不花你家的钱。等需要的时候ViewStub中的布局才加载到内存，多节俭持家啊。对于一些进度条，提示信息等等八百年才用一次的功能，使用ViewStub是极其合适的。这就是不用不知道，一用戒不了。
 
 
8.加载优化
 
 
这里并没有过多的技术点在里面，无非就是将耗时的操作封装到异步中去了，但是，有一点不得不提的是，要注意多进程的问题，如果你的应用是多进程，你应该认识到你的application的oncreate方法会被执行多次，你一定不希望资源加载多次吧，于是你只在主进程加载，如是有些坑就出现了，有可能其他进程需要那某份资源，然后他这个进程缺没有加载相应的资源，然后就嗝屁了。
 
 
9.刷新优化。
 
 
     
  
  • item 刷新
     对于列表的中的item的操作，比如对item点赞，此时不应该让整个列表刷新，而是应该只刷新这个item.
    •  
  
  • 复杂Activity刷新
     对于较为复杂的页面，个人建议不要写在一个activity中，建议使用几个fragment进行组装，这样一来，module的变更可以只刷新某一个具体的fragment，而不用整个页面都走刷新逻辑。但是问题来了，fragment之间如何共享数据呢？好，看我怎么操作。
    •  
 
 
 
 
  
 
   
 
    Android性能优化_第8张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
Activity将数据这部分抽象成一个LiveData，交个LiveDataManger数据进行管理，然后各个Fragment通过Activity的这个context从LiveDataManger中拿到LiveData,进行操作，通知activity数据变更等等。哈哈，你没有看错，这个确实和Google的那个LiveData有点像，当然，如果你想使用Google的那个，也自然没问题，只不过，这个是简化版的。项目的引入
 'com.tencent.tip:simple_live_data:1.0.1-SNAPSHOT'
 
 
10. 动画优化
 
 
耗损（耗电、流量）
 
 
耗电优化
 
 
     
  
  • 在定位精度要求不高的情况下，使用wifi或移动网络进行定位，没有必要开启GPS定位。
    •  
  
  • 先验证网络的可用性，在发送网络请求，比如，当用户处于2G状态下，而此时的操作是查看一张大图，下载下来可能都200多K甚至更大，我们没必要去发送这个请求，让用户一直等待那个菊花吧。
    •  
  
  • 适当的做本地缓存，避免频繁请求网络数据，这里，说起来容易，做起来并非三刀两斧就能搞定，要配合良好的缓存策略，区分哪些是一段时间不会变更的，哪些是绝对不能缓存的很重要。
    •  
 
 
 
安装包（Apk瘦身）
 
 
既然要瘦身，那么我们必须知道APK的文件构成，解压apk：
 
 
 
  
 
   
 
    Android性能优化_第9张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
-assets文件夹
 存放一些配置文件、资源文件，assets不会自动生成对应的 ID，而是通过 AssetManager 类的接口获取。
 
 
     
  
  • res目录
     res 是 resource 的缩写，这个目录存放资源文件，会自动生成对应的 ID 并映射到 .R 文件中，访问直接使用资源 ID。
    •  
  
  • META-INF
     保存应用的签名信息，签名信息可以验证 APK 文件的完整性。
    •  
  
  • AndroidManifest.xml
     这个文件用来描述 Android 应用的配置信息，一些组件的注册信息、可使用权限等。
    •  
  
  • classes.dex
     Dalvik 字节码程序，让 Dalvik 虚拟机可执行，一般情况下，Android 应用在打包时通过 Android SDK 中的 dx 工具将 Java 字节码转换为 Dalvik 字节码。
    •  
  
  • resources.arsc
     记录着资源文件和资源 ID 之间的映射关系，用来根据资源 ID 寻找资源。
    •  
 
 
 
我们需要从代码和资源两个方面去减少响应的大小。
 
 
1、首先我们可以使用lint工具，如果有没有使用过的资源就会打印如下的信息(不会使用的朋友可以上网看一下)
 
 
同时我们可以开启资源压缩,自动删除无用的资源
 
 
android {
    ...
    buildTypes {
        release {
            shrinkResources true
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                    'proguard-rules.pro'
        }
    }

 
 
2、能自己用XML写Drawable，就自己写，能不用公司的UI切图，就别和他们说话，咱们自己造，做自己的UI，美滋滋。而且这种图片占用空间会很小。
 
 
3、重用资源，比如一个三角按钮，点击前三角朝上代表收起的意思，点击后三角朝下，代表展开，一般情况下，我们会用两张图来切换，我们完全可以用旋转的形式去改变
 
 



 
 
4、压缩PNG和JPEG文件 您可以减少PNG文件的大小，而不会丢失使用工具如图像质量 pngcrush，pngquant，或zopflipng。所有这些工具都可以减少PNG文件的大小，同时保持感知的图像质量。
 
 
5、使用WebP文件格式 可以使用图像的WebP文件格式，而不是使用PNG或JPEG文件。WebP格式提供有损压缩（如JPEG）以及透明度（如PNG），但可以提供比JPEG或PNG更好的压缩。
 
 
可以使用Android Studio将现有的BMP，JPG，PNG或静态GIF图像转换为WebP格式。
 
 
6、使用矢量图形 可以使用矢量图形来创建与分辨率无关的图标和其他可伸缩Image。使用这些图形可以大大减少APK大小。一个100字节的文件可以生成与屏幕大小相关的清晰图像。
 
 
但是，系统渲染每个VectorDrawable对象需要花费大量时间 ，而较大的图像需要更长的时间才能显示在屏幕上。因此，请考虑仅在显示小图像时使用这些矢量图形。
 
 
不要把AnimationDrawable用于创建逐帧动画，因为这样做需要为动画的每个帧包含一个单独的位图文件，这会大大增加APK的大小。
 
 
7、代码混淆 使用proGuard 代码混淆器工具，它包括压缩、优化、混淆等功能。这个大家太熟悉了。不多说了。
 
 
8、插件化。 比如功能模块放在服务器上，按需下载，可以减少安装包大小。
 
 
减少安装包大小
 
 
代码混淆。使用IDE 自带的 proGuard 代码混淆器工具 ，它包括压缩、优化、混淆等功能。 资源优化。比如使用 Android Lint 删除冗余资源，资源文件最少化等。 图片优化。比如利用 PNG优化工具 对图片做压缩处理。推荐目前最先进的压缩工具Googlek开源库zopfli。如果应用在0版本以上，推荐使用 WebP图片格式。 避免重复或无用功能的第三方库。例如，百度地图接入基础地图即可、讯飞语音无需接入离线、图片库Glide\Picasso等。 插件化开发。比如功能模块放在服务器上，按需下载，可以减少安装包大小。 可以使用微信开源资源文件混淆工具——AndResGuard。一般可以压缩apk的1M左右大。
 
 
耗电优化
 
 
我们可能对耗电优化不怎么感冒，没事，谷歌这方面做得也不咋地，5.0之后才有像样的方案，讲实话这个优化的优先级没有前面几个那么高，但是我们也要了解一些避免耗电的坑，至于更细的耗电分析可以使用这个Battery Historian。
 
 
Battery Historian 是由Google提供的Android系统电量分析工具，从手机中导出bugreport文件上传至页面，在网页中生成详细的图表数据来展示手机上各模块电量消耗过程，最后通过App数据的分析制定出相关的电量优化的方法。
 
 
谷歌推荐使用JobScheduler，来调整任务优先级等策略来达到降低损耗的目的。JobScheduler可以避免频繁的唤醒硬件模块，造成不必要的电量消耗。避免在不合适的时间(例如低电量情况下、弱网络或者移动网络情况下的)执行过多的任务消耗电量。
 
 
具体功能：
 1、可以推迟的非面向用户的任务(如定期数据库数据更新)；
 2、当充电时才希望执行的工作(如备份数据)；
 3、需要访问网络或 Wi-Fi 连接的任务(如向服务器拉取配置数据)；
 4、零散任务合并到一个批次去定期运行；
 5、当设备空闲时启动某些任务；
 6、只有当条件得到满足, 系统才会启动计划中的任务（充电、WIFI...）；
 
 
同时谷歌针对耗电优化也提出了一个懒惰第一的法则：
 
 
减少 你的应用程序可以删除冗余操作吗？例如，它是否可以缓存下载的数据而不是重复唤醒无线电以重新下载数据？
 
 
推迟 应用是否需要立即执行操作？例如，它可以等到设备充电才能将数据备份到云端吗？
 
 
合并 可以批处理工作，而不是多次将设备置于活动状态吗？例如，几十个应用程序是否真的有必要在不同时间打开收音机发送邮件？在一次唤醒收音机期间，是否可以传输消息？
 
 
谷歌在耗电优化这方面确实显得有些无力，希望以后可以退出更好的工具和解决方案，不然这方面的优化优先级还是很低。付出和回报所差太大。
 
 
内存优化准则
 
 
     
  
  1. 能不创建的对象就不创建
     比如字符串拼接，可以手动使用StringBuilder，而不是使用"+"，"+"被编译器优化后会每次创建StringBuilder对象，造成浪费；
     而且，尤其注意在主线程里不要过多创建对象。因为在GC时会锁住堆内存，此时请求分配的线程也会被挂起，这显然会导致主线程的卡顿。所以在一些主线程高频函数，如onDraw，onTouchEvent里不要去创建对象。
    2.  
  
  2. 尽可能复用已经创建的对象
     还是StringBuilder的例子，基于一个StringBuilder可以通过SetLength(0)支持很多次的字符串拼接。
     多使用系统提供的对象池，比如线程池，Long、Integer、Short等包类型里的缓存值（通过valueOf取），列表view的复用等
    3.  
  
  3. 防止内存泄漏
     内存一旦发生泄漏，意味着堆里有一块区域持续被不再使用的变量占据，这自然会导致可用内存减少而发生gc，甚至OOM。
    4.  
 
 
 
代码建议
 
 
1. SparseArray代替HashMap
 
 
建议使用SparseArray代替HashMap,这里是Google建议的，因为SparseArray比HashMap更省内存，在某些条件下性能更好，主要是因为它避免了对key的自动装箱比如（int转为Integer类型），它内部则是通过两个数组来进行数据存储的，一个存储key，另外一个存储value，为了优化性能，它内部对数据还采取了压缩的方式来表示稀疏数组的数据，从而节约内存空间。
 
 
推荐使用match_parent，或者固定尺寸
 
 
不到不得已，不要使用wrap_content,,推荐使用match_parent,或者固定尺寸，配合gravity="center"。
 因为 在测量过程中，match_parent和固定宽高度对应EXACTLY ,而wrap_content对应AT_MOST,这两者对比AT_MOST耗时较多。
 
 
使用Link优化项目
 
 
Lint 是Android Studio 提供的 代码扫描分析工具，它可以帮助我们发现代码结构/质量问题，同时提供一些解决方案，而且这个过程不需要我们手写测试用例。
 
 
ListView和 Bitmap优化
 
 
针对ListView优化，主要是合理使用ViewHolder。创建一个内部类ViewHolder，里面的成员变量和view中所包含的组件个数、类型相同，在convertview为null的时候，把findviewbyId找到的控件赋给ViewHolder中对应的变量，就相当于先把它们装进一个容器，下次要用的时候，直接从容器中获取。
 
 
现在我们现在一般使用RecyclerView，自带这个优化，不过还是要理解一下原理的好。 然后可以对接受来的数据进行分段或者分页加载，也可以优化性能。
 
 
对于Bitmap，这个我们使用的就比较多了，很容易出现OOM的问题，图片内存的问题可以看一下我之前写的这篇文章一张图片占用多少内存。
 
 
Bitmap的优化套路很简单，粗暴，就是让压缩。 三种压缩方式：
 1.对图片质量进行压缩
 2.对图片尺寸进行压缩
 3.使用libjpeg.so库进行压缩
 
 
对图片质量进行压缩
 
 
  public static Bitmap compressImage(Bitmap bitmap){  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
            //质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中  
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);  
            int options = 100;  
            //循环判断如果压缩后图片是否大于50kb,大于继续压缩  
            while ( baos.toByteArray().length / 1024>50) {  
                //清空baos  
                baos.reset();  
                bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos);  
                options -= 10;//每次都减少10  
            }  
            //把压缩后的数据baos存放到ByteArrayInputStream中  
            ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());  
            //把ByteArrayInputStream数据生成图片  
            Bitmap newBitmap = BitmapFactory.decodeStream(isBm, null, null);  
            return newBitmap;  
        }  

 
 
对图片尺寸进行压缩
 
 
  /**
     * 按图片尺寸压缩 参数是bitmap
     * @param bitmap
     * @param pixelW
     * @param pixelH
     * @return
     */
    public static Bitmap compressImageFromBitmap(Bitmap bitmap, int pixelW, int pixelH) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
        if( os.toByteArray().length / 1024>512) {//判断如果图片大于0.5M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
            os.reset();
            bitmap.compress(Bitmap.CompressFormat.JPEG, 50, os);//这里压缩50%，把压缩后的数据存放到baos中
        }
        ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        options.inPreferredConfig = Bitmap.Config.RGB_565;
        BitmapFactory.decodeStream(is, null, options);
        options.inJustDecodeBounds = false;
        options.inSampleSize = computeSampleSize(options , pixelH > pixelW ? pixelW : pixelH ,pixelW * pixelH );
        is = new ByteArrayInputStream(os.toByteArray());
        Bitmap newBitmap = BitmapFactory.decodeStream(is, null, options);
        return newBitmap;
    }


    /**
     * 动态计算出图片的inSampleSize
     * @param options
     * @param minSideLength
     * @param maxNumOfPixels
     * @return
     */
    public static int computeSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {
        int initialSize = computeInitialSampleSize(options, minSideLength, maxNumOfPixels);
        int roundedSize;
        if (initialSize <= 8) {
            roundedSize = 1;
            while (roundedSize < initialSize) {
                roundedSize <<= 1;
            }
        } else {
            roundedSize = (initialSize + 7) / 8 * 8;
        }
        return roundedSize;
    }

    private static int computeInitialSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {
        double w = options.outWidth;
        double h = options.outHeight;
        int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));
        int upperBound = (minSideLength == -1) ? 128 :(int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));
        if (upperBound < lowerBound) {
            return lowerBound;
        }
        if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
            return 1;
        } else if (minSideLength == -1) {
            return lowerBound;
        } else {
            return upperBound;
        }
    }


 
 
使用libjpeg.so库进行压缩
 
 
可以参考这篇Android性能优化系列之Bitmap图片优化： https://blog.csdn.net/u012124438/article/details/66087785)
 
 
线程优化
 
 
线程优化的思想是采用线程池，避免在程序中存在大量的Thread。线程池可以重用内部的线程，从而避免了现场的创建和销毁所带来的性能开销，同时线程池还能有效地控制线程池的最大并发数，避免大量的线程因互相抢占系统资源从而导致阻塞现象发生。
 
 
《Android开发艺术探索》对线程池的讲解很详细，不熟悉线程池的可以去了解一下。
 
 
     
  
  • 优点：
     1、减少在创建和销毁线程上所花的时间以及系统资源的开销。
     2、如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。
    •  
 
 
 
     
  
  • 需要注意的是：
     1、如果线程池中的数量为达到核心线程的数量，则直接会启动一个核心线程来执行任务。
     2、如果线程池中的数量已经达到或超过核心线程的数量，则任务会被插入到任务队列中标等待执行。
     3、如果(2)中的任务无法插入到任务队列中，由于任务队列已满，这时候如果线程数量未达到线程池规定最大值，则会启动一个非核心线程来执行任务。
     4、如果(3)中线程数量已经达到线程池最大值，则会拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法通知调用者。
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android性能优化)

        

            

                
    
                    
  • Android性能优化之启动速度优化
                        Just_Paranoid
Androidandroid性能优化ProfilerSystrace
                        
    Android性能优化之启动速度优化1.App启动流程2.测试启动耗时的方法3.测试启动耗时的分析工具3.1AndroidProfiler3.2TraceView3.3Systrace4.如何优化启动时间4.1.减少DEX文件大小4.2优化Application初始化4.3优化Activity加载4.4使用启动引导页4.5使用启动优化库5.代码分析示例启动速度是衡量Android应用性能的重要指标
    
                    
    • 
                    
  • Android 性能优化实战：打造流畅体验
                        斯陀含
android性能优化
                        
    Android性能优化实战：打造流畅体验导言：Android应用的性能直接影响用户体验，流畅、快速、高效的应用才能吸引用户并留住用户。优化代码性能是提升用户体验的关键，而这需要我们深入理解Android系统的运行机制和性能瓶颈，并采取针对性的优化策略。本教程将带领你深入学习Android性能优化，涵盖代码优化、布局优化、渲染优化、内存优化、网络优化等多个方面，并提供丰富的实例和代码示例，帮助你快速
    
                    
    • 
                    
  • 安卓基础面试题
                        享哥。
android
                        
    自定义viewAndroid自定义View-CSDN博客view和viewgroupView和ViewGroup的区别-view的事件分发事件分发详解---历史最容易理解组件化Android-组件化开发什么是ANRAndroidANR详解-CSDN博客Android性能优化Android优化-CSDN博客Aroute原理Arouter框架原理浅解-简书2021年Android面试题汇总（初级）-简
    
                    
    • 
                    
  • Android性能优化有哪些方向和建议
                        Dyan_csdn
Androidandroid性能优化
                        
    目录技术层面架构层面技术层面Android性能优化是一个多方面的工作，涉及应用的流畅性、稳定性、资源消耗等多个维度。以下是一些主要的优化方向和建议：1.**流畅性优化**：-**启动速度**：通过异步加载、分步加载、延期加载等策略减少启动时的资源加载量。-**页面显示速度**：优化布局和视图层次，减少不必要的视图嵌套，使用`include`、`merge`标签减少布局文件的复杂度。-**响应速度*
    
                    
    • 
                    
  • Android性能优化之App启动速度、Apk体积缩减
                        SyShareS
Android开发Android性能优化
                        
    转发自：Android性能优化典范-第6季这里是Android性能优化典范第6季的课程学习笔记，从被@知会到有连载更新，这篇学习笔记就一直被惦记着，现在学习记录分享一下，请多多指教包涵！这次一共才6个小段落，涉及的内容主要有：程序启动时间性能优化的三个方面：优化activity的创建过程，优化application对象的启动过程，正确使用启动显屏达到优化程序启动性能的目的。另外还介绍了减少安装包大
    
                    
    • 
                    
  • 纯干货！Android性能优化面试题集锦，持续更新中
                        程序员大婕
程序员Android
                        
    第一次观看我文章的朋友，可以关注、点赞、转发一下，每天分享各种干货技术和程序猿趣事前言随着移动终端的快速发展，Android开发人员也越来越多，Android开发市场也进入了一个饱和的状态，Android开发人员也面临着难找一份好工作的处境。而找工作的第一关就是面试，一个好的面试往往能很好的提高你的入职几率，下面我总结了一些本人在一些大厂的面试总结，希望的观看的小伙伴有所帮助。Android基础&
    
                    
    • 
                    
  • Android 优化
                        perry_Fan

                        
    优化心得和经验系列视频AndroidPerformancePatterns给App提速：Android性能优化总结移动端性能监控方案HertzAndroid性能优化后续Android性能优化之虚拟机调优AndroidUI性能优化PerformanceTips美团外卖AndroidLint代码检查实践Androidbatteryandmemoryoptimizations-GoogleI/O2016
    
                    
    • 
                    
  • Android开发必学：Android性能优化之APK优化，面试真题解析
                        NathanEmily
程序员Android
                        
    我，来自大山。我，不甘平凡。笔者80后，出生在江西一个偏远的山村。虽然出生时已经不是那个温饱都是问题的年代，但是也谈不上有个幸福的童年。家里很穷。幼儿园并没有读，因为家里觉得花那个钱没有必要，小学才开始学拼音字母。我的童年，就是和我的姐姐弟弟在山中的梯田里放牛，抓泥鳅，割鱼草。父亲在广东打工，母亲一个人在家里带着我们三个孩子。种种原因，在我从小学开始到高中毕业，我的学习一直很差。直到我高考成绩出来
    
                    
    • 
                    
  • Android性能优化全攻略：让你的应用飞起来
                        Calvin880828
Android性能android性能优化
                        
    Android性能优化全攻略：让你的应用飞起来引言在移动设备上，用户期望获得流畅、响应迅速的应用体验。对于Android开发者而言，优化应用的性能不仅能提升用户满意度，还能显著增加应用的市场竞争力。性能瓶颈可能来源于多方面，包括但不限于布局复杂、内存泄漏、不当的资源管理等。认识到这些问题并采取相应的优化措施，是每个Android开发者的必修课。理解Android性能指标在深入优化之前，了解如何衡量
    
                    
    • 
                    
  • android 应用最大内存卡,Android性能优化---内存优化
                        CYDYSY
android应用最大内存卡
                        
    读书笔记：Android应用性能优化最佳实践一、影响卡顿的基本原因1.绘制任务太重2.主线程任务耗时太长二、页面绘制的流程CPU准备数据---GPU从缓存列表获取数据----Display显示数据三、性能优化检测工具1.ProfileGPUrendering：GPU呈现模式分析或是使用dumpsys命令更直观的查看绘制的耗时adbshelldumpsysgfxinfocom.efrobot.rob
    
                    
    • 
                    
  • Android性能优化-------内存优化
                        原总破局
Android开发android
                        
    Webview内存泄漏org.chromium.android_webview.AwContents我们会在onAttachedToWindow中进行注册，在onDetachedFromWindow中进行解注册publicvoidonDetachedFromWindow(){if(isDestroyed())return;if(!mIsAttachedToWindow){Log.w(TAG,"on
    
                    
    • 
                    
  • 2022-03-12
                        daoshou007

                        
    Android性能优化：这是一份全面&详细的内存优化教程前言在Android开发中，性能优化策略十分重要本文主要讲解性能优化中的内存优化，希望你们会喜欢目录1.定义优化处理应用程序的内存使用、空间占用2.作用避免因不正确使用内存&缺乏管理，从而出现内存泄露（ML）、内存溢出（OOM）、内存空间占用过大等问题，最终导致应用程序崩溃（Crash）3.储备知识：Android内存管理机制3.1简介下面，
    
                    
    • 
                    
  • 【Android性能优化】内存优化前置知识剖析
                        Shujie_L
#Android性能优化android性能优化
                        
    文章目录前言内存核心指标VSS（VirtualSetSize）RSS（ResidentSetSize）PSS（ProportionalSetSize）VSS和RSS的区别USS（UniqueSetSize）adbshelladbshellgetpropro.product.modeladbshelldumpsysbatteryadbshellwmsizeadbshellwmdensityadbsh
    
                    
    • 
                    
  • Android性能优化汇总
                        MadnessXiong

                        
    Android性能优化可以从以下几个方面展开流畅度优化内存优化电量优化安装包优化流畅度优化：Android设备的刷新频率一般是是60HZ也就是一秒60帧，每一帧16ms左右。每一帧数据都会经过CPU计算，GPU合成格栅化然后显示出来首先需要明白为什么会卡：Android4.1后引入了VSync机制(垂直同步)，可以简单理解为定时中断，每一个VSync间隔是16ms左右，每一个VSync开始时会通知
    
                    
    • 
                    
  • Android性能优化-缓存的使用
                        wfunny

                        
    前言最近又对数据缓存有了新的认识，所以来记录下我对缓存的理解，以及我在项目中是如何使用的。为什么需要数据缓存以下为我个人看法。考虑极端环境下的用户体验断网情况网速慢的情况节省客户端流量减少服务器压力什么样的数据需要缓存首先最需要缓存的就是图片了(这个不多说)其次就是一些非常重要的数据(如app首页数据)常见的数据缓存方法以及优缺点文件缓存优点可以缓存超大数据(实际用途很小)缺点读写开销大数据库缓存
    
                    
    • 
                    
  • （九）Android 性能优化 APK 分析器
                        科技猿人

                        
    小酌鸡汤人生在勤，不索何获。本文来源《Android性能优化全家桶》什么是APK分析器？ AndroidStudio包含一个APK分析器，可让您在构建流程完成后立即了解APK的组成。使用APK分析器可以减少调试应用的DEX文件和资源相关问题所用的时间，并且有助于减小APK的大小。APK分析器可以干什么？查看APK中的文件（如DEX和Android资源文件）的绝对大小和相对大小。了解DEX文件的组成
    
                    
    • 
                    
  • 转载-android性能优化
                        Keung丶
Android笔记android
                        
    android性能优化Reason:BroadcastofIntent{act=android.intent.action.TIME_TICKActivityManager:ANRincom.***.***PID:16227Reason:BroadcastofIntent{act=android.intent.action.TIME_TICKflg=0x50000014(hasextras)}有那
    
                    
    • 
                    
  • Android性能优化：直播推流使用对象池
                        一叶飘舟
java
                        
    #性能优化之Android应用内存优化实战#对应视频：3.为什么要学习数据结构与算法_哔哩哔哩_bilibili根据AndroidHandler里面的Message实现思想，实现自定义的对象池publicclassRTMPPackage{privatestaticfinalStringTAG="RTMPPackage";publicstaticfinalintRTMP_PACKET_TYPE_VI
    
                    
    • 
                    
  • Android性能优化：网络优化
                        ADark0915

                        
    http://www.baidu.comhttp://blog.csdn.net/u012963909/article/details/51204467
    
                    
    • 
                    
  • android应用开发基础学习心得体会
                        x18275767219
android学习
                        
    目录导语1.学习Java编程语言2.熟悉AndroidStudio3.学习Android开发框架4.实验室和样例代码5.Android数据存储和管理6.Android性能优化7.Android进阶开发导语Android开发是移动应用开发的一个重要领域，也是目前市场需求量较大的技能之一。作为一名Android开发者，你可以通过自己的技能和创造力，为用户提供高质量的应用程序。学习Android开发需要
    
                    
    • 
                    
  • Android性能优化总结
                        一亿元的日落

                        
    在Android开发过程中，我们经常会遇到App启动慢、页面跳转慢、事件响应慢、滑动和动画卡顿、内容显示慢等问题，因此要对项目进行性能优化，那么该怎么进行性能优化呢？我们从以下几个方面进行入手，讲解一下如何对Android的性能进行优化：启动优化内存优化布局优化卡顿优化网络优化电量优化稳定性优化1.启动优化预览窗口优化：将App启动页背景设置成闪屏页图片，可以让用户无感知平滑过渡进入App中；业务
    
                    
    • 
                    
  • Android性能优化之启动优化(实战篇)
                        VincentStory

                        
    目录一、启动优化的意义二、启动时间检测三、启动优化工具---traceview四、优化方案1.异步初始化2.延迟初始化3.懒加载五、源码地址六、总结一、启动优化的意义用户新安装一个app，第一印象很重要，那首先给用户感受的就是启动时间，如果用户等待时间过长，就体验很差，如果我们能在满足功能的基础上，把启动时间提升一个等级，无疑给我们的产品赢得更多的用户量打下来基础。二、启动时间检测//添加监听mV
    
                    
    • 
                    
  • Android开发中的日常
                        MrOneside
AndroidAndroid性能优化测试编码布局
                        
    Android开发中的日常积累HTTP2.0测试是否支持http2.0，需httpvshttpschrome插件HTTP/2andSPDYindicatorHTTP/2资料汇总HTTP2.0的那些事http2-spec从启用HTTP/2导致网站无法访问说起Android性能优化Android性能优化视频，文档以及工具胡凯-性能优化Android最佳性能实践(1)：合理管理内存Android最佳性能
    
                    
    • 
                    
  • Android 开发中的日常积累
                        cym492224103
Android开发精要篇
                        
    Android性能优化Android性能优化视频，文档以及工具胡凯-性能优化Android最佳性能实践(1)：合理管理内存Android最佳性能实践(2)：分析内存的使用情况Android最佳性能实践(3)：高性能编码优化Android最佳性能实践(4)：布局优化技巧ReactNative专题Facebook的react-nativeReactNative:配置和起步ReactNative:And
    
                    
    • 
                    
  • Android性能优化典范之多线程篇
                        shangguansb
android优化
                        
    ThreadingPerformance在程序开发的实践当中，为了让程序表现得更加流畅，我们肯定会需要使用到多线程来提升程序的并发执行性能。但是编写多线程并发的代码一直以来都是一个相对棘手的问题，所以想要获得更佳的程序性能，我们非常有必要掌握多线程并发编程的基础技能。众所周知，Android程序的大多数代码操作都必须执行在主线程，例如系统事件(例如设备屏幕发生旋转)，输入事件(例如用户点击滑动等)
    
                    
    • 
                    
  • Android性能优化调研——UI布局优化
                        晓娜点点
Android
                        
    Android性能优化调研——UI布局优化：关于Android性能优化文章请参照：http://mp.weixin.qq.com/s?__biz=MzIwNjQ1NzQxNA==&mid=2247483802&idx=1&sn=baaf65910acfa1aebe20a727daeb9877&scene=21#wechat_redirectUI布局优化：主要的思路是减少布局层级嵌套，在布局上多使用
    
                    
    • 
                    
  • Android面试常问一百题(第1题)——Android性能优化
                        nibolyoung
Android面试android面试性能优化
                        
    老生常谈、不论几面基本都会问的问题：Android性能优化1.Android性能优化主要包括哪些方面？2.如何进行布局优化？3.怎样进行安装包优化？3.1res资源优化：3.2代码优化：3.3lib资源优化：3.4assets资源优化：3.5代码混淆3.6使用proGuard代码混淆器工具，它包括压缩、优化、混淆等功能。3.7插件化3.8可将功能模块放服务器，需要用时再加载。3.97z极限压缩4.
    
                    
    • 
                    
  • Android性能优化系列之 —— UI 优化 （2）
                        Super 含
心得随便记录
                        
    序最近大家经常谈的话题围绕着"毕业985，工作996，离职251，访问404"。反正争议很大，但是我立场很明确（准备安排的mater30pro也因为资金问题变得遥遥无期）。Android的性能优化几乎是面试必考题，答案的结构很唯一无非就是内存优化、卡顿优化、I/O优化、UI优化、启动优化、储存优化、闪退优化、网络优化、耗电优化、包体积优化等等。但是面试的时候只要把任意一个结构突突的很透彻，当前的O
    
                    
    • 
                    
  • Android性能优化——UI优化
                        贾小牛
安卓开发基础android性能优化ui界面优化
                        
    1、使用标签来共享布局可以把头文件、其他xml公用多的部分抽取到一个xml中，用layout标签实现共享2、使用标签来优化布局层数在使用了include后可能导致布局嵌套过多，多余不必要的layout节点，从而导致解析变慢，不必要的节点和嵌套可通过hierarchyviewer(下面布局调优工具中有具体介绍)或设置->开发者选项->显示布局边界查看。merge标签可用于两种典型情况：布局顶结点是F
    
                    
    • 
                    
  • Android性能优化系列——内存优化
                        &岁月不待人&
Android优化性能优化
                        
    内存，是Android应用的生命线，一旦在内存上出现问题，轻者内存泄漏造成App卡顿，重者直接crash，因此一个应用保持健壮，要做好内存的使用和优化。网上有很多讲JAVA内存虚拟机的好文章，我就不赘述了。今天主要总结下内存优化。作为一个开发者，需要在平时的代码中就要多注意，如有不合理的地方，则需要进行优化。一、内存泄漏(memoryleak)：内存泄漏就是在当前应用周期内不再使用的对象被GCRo
    
                    
    • 
                                
  • apache ftpserver-CentOS config
                                    gengzg
apache
                                    
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://mina.apache.o
    
                                
    • 
                                
  • 优化MySQL数据库性能的八种方法
                                    AILIKES
sqlmysql
                                    
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    
                                
    • 
                                
  • JeeSite 企业信息化快速开发平台
                                    Kai_Ge
JeeSite
                                    
    JeeSite 企业信息化快速开发平台  
平台简介 
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    
                                
    • 
                                
  • 通过Spring Mail Api发送邮件
                                    120153216
邮件main
                                    
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 
Spring Mail API都在org.spri
    
                                
    • 
                                
  • Pysvn 程序员使用指南
                                    2002wmj
SVN
                                    
    源文件:http://ju.outofmemory.cn/entry/35762 
这是一篇关于pysvn模块的指南. 
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. 
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 
该
    
                                
    • 
                                
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
                                    357029540
SQL Server
                                    
    SELECT  R.session_id AS BlockedSessionID ,  
        S.session_id AS BlockingSessionID ,  
        Q1.text AS Block
    
                                
    • 
                                
  • Intent 常用的用法备忘
                                    7454103
.netandroidGoogleBlogF#
                                    
    Intent 
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 
 
下面列出几种Intent 的用法 
显示网页: 
 

    
                                
    • 
                                
  • Spring定时器时间配置
                                    adminjun
spring时间配置定时器
                                    
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />  
测试的时候，由于是每天定时执行，所以后面三个数
    
                                
    • 
                                
  • POJ 2421 Constructing Roads 最小生成树
                                    aijuans
最小生成树
                                    
    来源：http://poj.org/problem?id=2421 
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 
代码： 
 
#include <iostream>
#include <cstdio>
    
                                
    • 
                                
  • 重构笔记——提取方法（Extract Method）
                                    ayaoxinchao
java重构提炼函数局部变量提取方法
                                    
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。 
  
下面是我学习这个重构手法的笔记： 
  
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    
                                
    • 
                                
  • 为UILabel添加点击事件
                                    bewithme
UILabel
                                    
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。 
  
  UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
                                    bijian1013
redis数据库NoSQL
                                    
    一.redis.php 
<?php
      //实例化
      $redis = new Redis();
      //连接服务器
      $redis->connect("localhost");
      //授权
      $redis->auth("lamplijie");
      //相关操
    
                                
    • 
                                
  • SecureCRT使用备注
                                    bingyingao
secureCRT每页行数
                                    
    SecureCRT日志和卷屏行数设置 
 
一、使用securecrt时，设置自动日志记录功能。 
 
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 
 
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    
                                
    • 
                                
  • 【Scala九】Scala核心三：泛型
                                    bit1129
scala
                                    
    泛型类 
package spark.examples.scala.generics

class GenericClass[K, V](val k: K, val v: V) {
  def print() {
    println(k + "," + v)
  }
}

object GenericClass {
  def main(args: Arr
    
                                
    • 
                                
  • 素数与音乐
                                    bookjovi
素数数学haskell
                                    
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。 
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-IdentityHashMap
                                    BrokenDreams
Collections
                                    
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。 
        简单的说，IdentityHashMap和HashM
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 



import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    
                                
    • 
                                
  • PS人像润饰&调色教程集锦
                                    cherishLC
PS
                                    
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 
 
http://www.howzhi.com/course/retouching/ 
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。 
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    
                                
    • 
                                
  • 更新多个字段的UPDATE语句
                                    crabdave
update
                                    
    更新多个字段的UPDATE语句 
  
                 
                update tableA a
                   set (a.v1, a.v2, a.v3, a.v4) =   --使用括号确定更新的字段范围
          
    
                                
    • 
                                
  • hive实例讲解实现in和not in子句
                                    daizj
hivenot inin
                                    
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 
 
 
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 
 
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    
                                
    • 
                                
  • 一道24点的10+种非人类解法（2,3,10,10）
                                    dsjt
算法
                                    
    这是人类算24点的方法？！！！ 
 
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 
 
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 
 
然后么。。。我就在深夜很得瑟的问室友求室友算 
 
刚出完题，文哥的暴走之旅开始了 
 
5秒后
    
                                
    • 
                                
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
                                    dcj3sjt126com
yiiframework
                                    
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    
                                
    • 
                                
  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
                                    come_for_dream
对象
                                    
    概述 
  
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。 
  
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    
                                
    • 
                                
  • 学习编程那点事
                                    gcq511120594
编程互联网
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • Reverse Linked List II
                                    hcx2013
list
                                    
    Reverse a linked list from position m to n. Do it in-place and in one-pass. 
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, 
return 
    
                                
    • 
                                
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Hadoop集群工具distcp
                                    liyonghui160com

                                    
      
  
1. 环境描述 
两个集群：rock 和 stone 
rock无kerberos权限认证，stone有要求认证。 
1. 从rock复制到stone，采用hdfs 
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    
                                
    • 
                                
  • 一个备份MySQL数据库的简单Shell脚本
                                    pda158
mysql脚本
                                    
    　　主脚本（用于备份mysql数据库）：   　　该Shell脚本可以自动备份 
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。   　　 
1. 分别建立目录“backup”和“oldbackup”   　　#mkdir /backup   　　#mkdir /oldbackup   　
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
                                    shoothao
IT资源图标库图片库色彩板字体
                                    
     
 A. 免费的设计资源 
 
 
  Freebbble:来自于Dribbble的免费的高质量作品。 
  Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 
  Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 
  Pixel Buddha:免费和优质资源的专业社区。 
  Premium Pixels:为那些有创意的人提供免费的素材。 
  
    
                                
    • 
                                
  • thrift总结 - 跨语言服务开发
                                    uule
thrift
                                    
    官网 
官网JAVA例子 
thrift入门介绍 
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 
Thrift入门及Java实例演示 
thrift的使用介绍 
  
RPC  
  
POM： 
<dependency>
  <groupId>org.apache.thrift</groupId>
  
    
                                
    •