性能优化

最新推荐文章于 2021-10-30 16:05:05 发布
最新推荐文章于 2021-10-30 16:05:05 发布
阅读量139 收藏 1
点赞数
分类专栏： android 文章标签： android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_12345_liu/article/details/108632821
版权

文章目录

View布局优化

布局优化首先我们应该做的就是尽可能的减少布局文件的层级，当布局的层级减少了，那绘制的性能自然就提高了，同时还可以使用下面的方式来优化我们的布局。
1.优先选择高性能的ViewGroup
android中界面布局使用android中提供的控件就可以，但是在使用的时候可以根据场景择优选择所需的控件，在选择ViewGroup的时候，可以优先选择性能较高的FrameLayout和LinearLayout，因为RelativeLayout较为费时，但是如果布局需要进行嵌套，可以考虑使用RelativeLayout来实现布局，以达到减少布局层级的目的。
2.可以使用TextView的leftDrawabel/rightDrawable代替ImageView+TextView布局，减少View的数量
3.使用include和merge标签重复利用布局，同时减少嵌套

  1. 使用include标签我们可以将公共的布局抽取出来，这样公共的布局我们不用总是重新再写一遍，同时include标签只支持 android:layout_ 开头的属性和android:id 属性，其他的属性不支持，同时在使用该属性的时候，如果使用了android:layout_*开头的其他属性，那么layout_width和layout_height属性必须同时存在，否则设置的android:layout_*开头的属性不起作用。
  2. 使用merge标签可以用来减少布局的层级，当使用include标签引用布局的时候，如果被引用布局的根布局和include标签的父布局为同一布局，就可以使用merge标签替换被引用布局的根布局标签。
  • 自己在尝试的过程中发现，使用include标签时，如果被引用布局的根元素使用merge标签，include属性设置android:layout_属性将不起作用，而需要在merge标签内设置include属性，这样include标签的android:layout_属性才会起作用。（此处为自己通过demo简单实践后得到的，如果有错误还请指正）

不起作用的写法：
layout布局

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".LayoutPerformanceActivity">

    <!--注意layout前面没android开头的命名空间-->
    <include
        android:id="@+id/reused_image"
        layout="@layout/commonimageview"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="20dp"/>
</LinearLayout>

被引用布局

<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@mipmap/ic_launcher_round" />
</merge>

运行结果：layout_margin属性不起作用

  • 起作用的写法
    修改被引用布局结构，在merge标签中使用include标签引用布局
<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <include
        android:id="@+id/reused_image"
        layout="@layout/stub_layout"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="10dp" />
</merge>

stub_layout布局文件仅为一个图片：

<ImageView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/image"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@mipmap/ic_launcher" />

运行后查看在merge里面的include使用layout_margin属性起作用了。。
3.使用ViewStub标签进行按需加载
ViewStub继承了View,自身不参与任何布局和绘制过程，当我们在开发中，一些布局在初始化时没有必要一起进行初始化，这时就可以使用ViewStub来按需加载该布局，因为当view设置为Gone或者Invisiable的时候，还是会占资源，具体参见（Android 使用View Gone 与 ViewStub的区别）
但是需要注意的是ViewStub的引用布局不支持merge标签
ViewStub使用方式

    <ViewStub
        android:id="@+id/stub_import"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:inflatedId="@+id/stub_import_view"
        android:layout="@layout/stub_import" />

android:id指定的即为ViewStub的id，当ViewStub被替换后，加载后得到的布局的Id即为android:inflatedId指定的id。
加载方式：

// mViewStub为 mViewStub = findViewById(R.id.stub_import);
mViewStub.setVisibility(View.VISIBLE);

代码：include标签和merge标签使用以及ViewStub标签使用

App绘制耗时分析工具Hierarchy Viewer

分析界面加载耗时情况时，可以使用Hierarchy Viewer工具去分析，
使用HierarchyViewer工具

查看过度绘制Overdraw

在"调试GPU过度绘制"中开启过度绘制调试:

Overdraw：用来描述一个像素在屏幕上重绘了多少次

在这里插入图片描述
原色: 没有overdraw
蓝色: 1次overdraw
绿色: 2次overdraw
粉色: 3次overdraw
红色: 4次及4次以上的overdraw

一般来说, 蓝色是可接受的, 是性能优的.

查看我们的代码如果有过度绘制的话，我们尽量优化代码减少过度绘制，以优化我们的布局。

硬件加速绘制和HARDWARE_LAYER

什么是硬件加速绘制？

实际上应该叫 GPU 加速，软硬件加速的区别主要是图形的绘制究竟是 GPU 来处理还是 CPU，如果是 GPU，就认为是硬件加速绘制，反之，则是软件绘制

如果TargetAPI的级别在14及以上，硬件加速是默认开启的。在判断View是否使用硬件加速绘制的时候，可以使用下面的方式去判断：

 chat_wv.post(new Runnable() {
      @Override
      public void run() {
        Log.e("isHardwareAccelerated", ""+chat_wv.isHardwareAccelerated());
      }
    });

如果在创建View之后就直接使用isHardwareAccelerated()方法去判断，这样会得到false，因为view只是刚创建。
使用硬件加速的情况下绘制效率要优于软件加速，但同时也会增加内存消耗。
什么是HARDWARE_LAYER？
首先Layer的概念主要是针对View的：

LAYER_TYPE_NONE: The view is rendered normally and is not backed by an off-screen buffer. This is the default behavior.
LAYER_TYPE_HARDWARE: The view is rendered in hardware into a hardware texture if the application is hardware accelerated. If the application is not hardware accelerated, this layer type behaves the same as LAYER_TYPE_SOFTWARE.
LAYER_TYPE_SOFTWARE: The view is rendered in software into a bitmap.

查看官方解释，Hardware layer表示拥有一个在硬件上渲染的缓冲区，当然只有开启硬件加速才会有该缓冲区，所以Hardware layer依赖硬件加速打开，当硬件加速没有打开的时候，使用Hardware layer效果和LAYER_TYPE_SOFTWARE一样。
使用Hardware layer的作用：
hardware layer 可用于将复杂视图树缓存到纹理中，并降低绘制操作的复杂性。 例如，在使用旋转动画时，可以使用硬件层仅渲染视图树一次，不用反复渲染，提高效率。

    view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    ObjectAnimator animator = ObjectAnimator.ofFloat(view, "rotationY", 180);
    animator.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            view.setLayerType(View.LAYER_TYPE_NONE, null);
        }
    });
    animator.start();

使用HardwareLayer的时候，需要在使用完成后将layer type设置为LAYER_TYPE_NONE，这样才能释放HardwareLayer占用的内存。
在执行属性动画（ alpha \ translation \ scale \ rotation ）的时候，只是更新View的Property，每一帧不会去销毁和重建缓存，因此设置为hardware layer对性能有很大的提升。但是如果在onAnimationUpdate中做了添加删除view的操作，或者一直invalidate()，使得视图反复刷新，反而会使得动画性能变差。
查看动画帧率效果的时候可以使用下面的命令来获取App的帧率信息
adb shell dumpsys gfxinfo 包名
参考：Android 中的 Hardware Layer 详解

异步加载Bitmap

加载bitmap的时候，如果bitmap加载的时候不是从内存中实时读取的话，那么这个时候就不应该在主线程中进行加载，因为磁盘读写速度，CPU处理能力，网络环境等都没办法确保图片可以实时加载，从而造成卡顿甚至是ANR（activity位于前台5s,广播10s），
下面例子加载的时候使用AsyncTask:

使用AsyncTask的时候，实现doInBackground()方法，该方法会在子线程中执行，我们可以在该方法中执行耗时操作，但是execute的调用必须放到主线程中。

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
        // WeakReference用来防止内存泄漏
        private final WeakReference<ImageView> imageViewReference;
        private int data = 0;

        public BitmapWorkerTask(ImageView imageView) {
            // Use a WeakReference to ensure the ImageView can be garbage collected
            imageViewReference = new WeakReference<ImageView>(imageView);
        }

        // Decode image in background.
        @Override
        protected Bitmap doInBackground(Integer... params) {
            data = params[0];
            return decodeSampledBitmapFromResource(getResources(), data, 100, 100);
        }

        // Once complete, see if ImageView is still around and set bitmap.
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (imageViewReference != null && bitmap != null) {
                final ImageView imageView = imageViewReference.get();
                // 如果imageView被GC回收了就不执行
                if (imageView != null) {
                    imageView.setImageBitmap(bitmap);
                }
            }
        }
    }

-----------------------------------------------------------------------------

// 使用
public void loadBitmap(int resId, ImageView imageView) {
    BitmapWorkerTask task = new BitmapWorkerTask(imageView);
    task.execute(resId);
}

上面的代码使用WeakReference来引用ImageView对象，这样可以防止内存泄漏。Android中的各种引用的回收情况如下：

强引用：当JVM内存空间不足，JVM宁愿抛出OutOfMemoryError运行时错误（OOM），使程序异常终止，也不会靠随意回收具有强引用
软引用： 软引用的生命周期比强引用短一些。只有当 JVM 认为内存不足时，才会去试图回收软引用指向的对象
弱引用：弱引用通过WeakReference类实现。 弱引用的生命周期比软引用短。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

上面的代码完成了实现了图片的异步加载。但是由于Android中的控件会有一套View的回收复用机制，所以这里需要处理View复用的情况：

  1. 自定义图片加载的Task.
  2. 自定义一个Drawable,包含一个默认的Bitmap和一个Task,默认的Bitmap用于初始时的显示,Task用于加载图片并显示.
  3. 在每次绑定childView和Task的时候,由于childView可能是由之前的View复用而来,应此先判断该View是否已经绑定了Task,若有则取消重新绑定,若无则直接绑定.
  4. 将childView和要加载的图片的Task绑定.

1.自定义的图片加载器子线程加载的代码见上面的BitmapWorkerTask，只不过在onPostExecute时我们需要判断线程是否cancel，以及imageView是否被复用和回收。

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
    ...

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        if (isCancelled()) {
            bitmap = null;
        }

        if (imageViewReference != null && bitmap != null) {
            final ImageView imageView = imageViewReference.get();
            final BitmapWorkerTask bitmapWorkerTask =
                    getBitmapWorkerTask(imageView);
            // 判断非空
            if (this == bitmapWorkerTask && imageView != null) {
                imageView.setImageBitmap(bitmap);
            }
        }
    }
}

2.自定义Drawable，Drawable中存储当前加载图片的BitmapWorkerTask的弱引用：

static class AsyncDrawable extends BitmapDrawable {
    private final WeakReference<BitmapWorkerTask> bitmapWorkerTaskReference;

    public AsyncDrawable(Resources res, Bitmap bitmap,
            BitmapWorkerTask bitmapWorkerTask) {
        super(res, bitmap);
        bitmapWorkerTaskReference =
            new WeakReference<BitmapWorkerTask>(bitmapWorkerTask);
    }

    public BitmapWorkerTask getBitmapWorkerTask() {
        return bitmapWorkerTaskReference.get();
    }
}

获取View绑定的WorkerTask,通过自定义过的Drawable中存储的Task，可以获取到WorkerTask。

private static BitmapWorkerTask getBitmapWorkerTask(ImageView imageView) {
   if (imageView != null) {
       final Drawable drawable = imageView.getDrawable();
       if (drawable instanceof AsyncDrawable) {
           final AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;
           return asyncDrawable.getBitmapWorkerTask();
       }
    }
    return null;
}

判断是否取消ImageView绑定的Task,注意下面的data只是一个标识符，用于判断该Task是否是所需要的Task,如果是自己当前需要加载的资源的Task，就没必要cancel了，因为当前的imageview加载的就是需要的资源

public static boolean cancelPotentialWork(int data, ImageView imageView) {
    final BitmapWorkerTask bitmapWorkerTask = getBitmapWorkerTask(imageView);

    if (bitmapWorkerTask != null) {
        final int bitmapData = bitmapWorkerTask.data;
        // If bitmapData is not yet set or it differs from the new data
        if (bitmapData == 0 || bitmapData != data) {
            // Cancel previous task
            bitmapWorkerTask.cancel(true);
        } else {
            // The same work is already in progress
            return false;
        }
    }
    // No task associated with the ImageView, or an existing task was cancelled
    return true;
}

入参的时候传入两个参数：ImageView和data，防止图片加载错乱。

public void loadBitmap(int resId, ImageView imageView) {
	// cancelPotentialWork判断是否需要再次加载。
    if (cancelPotentialWork(resId, imageView)) {
        // 如果取消了就重新创建一个新的Task
        final BitmapWorkerTask task = new BitmapWorkerTask(imageView);
        final AsyncDrawable asyncDrawable =
                new AsyncDrawable(getResources(), mPlaceHolderBitmap, task);
        imageView.setImageDrawable(asyncDrawable);
        task.execute(resId);
    }
}

参考：
DisplayingBitmaps
https://www.jianshu.com/p/4b6f57646745

AsyncLayoutInflater异步加载布局

官方链接
使用AsyncLayoutInflater可以在子线程中加载我们的布局，这样不会影响主线程ui。
代码中我们使用以下方式进行使用

        new AsyncLayoutInflater(this).inflate(R.layout.activity_async_load, null, new AsyncLayoutInflater.OnInflateFinishedListener() {
            @Override
            public void onInflateFinished(@NonNull View view, int resid, @Nullable ViewGroup parent) {
                setContentView(R.layout.activity_main);
                Log.i(TAG, "onInflateFinished: ");
            }
        });

https://www.jianshu.com/p/f0c0eda06ae4
使用的时候我们需要注意以下几点（官方文档中有说明）

  1. 使用异步 inflate，那么需要这个 layout 的 parent 的 generateLayoutParams 函数是线程安全的；
  2. 所有构建的 View 中必须不能创建 Handler 或者是调用 Looper.myLooper；（因为是在异步线程中加载的，异步线程默认没有调用 Looper.prepare ）；
  3. 异步转换出来的 View 并没有被加到 parent view中，AsyncLayoutInflater 是调用了 LayoutInflater.inflate(int, ViewGroup, false)，因此如果需要加到 parent view 中，就需要我们自己手动添加；
  4. AsyncLayoutInflater 不支持设置 LayoutInflater.Factory 或者 LayoutInflater.Factory2；
  5. 不支持加载包含 Fragment 的 layout；
  6. 如果 AsyncLayoutInflater 失败，那么会自动回退到UI线程来加载布局；
    使用NinePatch
liu_12345_liu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android列表下载图片listview缓存
cf8833的博客
04-22 1031
在使用listview下载图片的时候，经常遇到图片错乱问题，快速滑动会导致图片位置不对，这里提供一种思路（1）activity_main.xml&lt;ListView android:id="@+id/list_view" android:layout_width="match_parent" android:layout_height="match_parent"/&g...
Android性能优化之Overdraw
Alex
06-01 647
Overdraw(过度绘制)描述的是屏幕上的某个像素在同一帧的时间内被绘制了多次。在多层次的UI结构里面，如果不可见的UI也在做绘制的操作，这就会导致某些像素区域被绘制了多次。这就浪费大量的CPU以及GPU资源。 当设计上追求更华丽的视觉效果的时候，我们就容易陷入采用越来越多的层叠组件来实现这种视觉效果的怪圈。这很容易导致大量的性能问题，为了获得最佳的性能，我们必须尽量减少Overdraw的情况发
【Google官方教程】第二课：在非UI线程处理Bitmap
cibaoqb025084的博客
11-10 147
转载声明：Ryan的博客文章欢迎您的转载，但在转载的同时，请注明文章的来源出处，不胜感激！ :-) http://my.oschina.net/ryanhoo/blog/88344 译者：Ryan Hoo 来源：https://developer.androi...
Bitmap 处理之不要在UI主线程中处理Bitmap
android leanring
04-27 3680
原文链接 http://developer.android.com/intl/zh-CN/training/displaying-bitmaps/process-bitmap.html 在使用BitmapFactory.decode*解析图片时，最好不要在UI主线程中处理，因为图片的来源是未知的，有可能是从硬盘读取的，也有可能是是网络的图片资源，这时在解析图片时，会有一些不可控的因素，如(网
安卓开发之Bitmap(位图)基础学习
iris的博客
06-23 638
在Android中，不管简单的还是复杂的控件或布局都直接或间接的继承自View。简单来说，AppUI界面上的每一个组件都是使用View和ViewGroup对象的层次结构构成的，如下图所示： View是绘制在屏幕上的用户能与之交互的一个对象。而ViewGroup则是一个用于存放其他View（和ViewGroup）对象的布局容。 ...
postgresql性能优化
02-24
【PostgreSQL性能优化】 在PostgreSQL数据库环境中，性能优化是一个至关重要的任务，它涉及到SQL查询的效率、索引的合理使用、内存管理以及查询规划等多个方面。以下是一些关键的性能优化策略： **一、排序优化** ...
Tomcat性能优化
03-09
【标题】：“Tomcat性能优化”意味着我们正在探讨如何提升Apache Tomcat服务器的运行效率，使其在处理Web应用时能够更快、更稳定地工作。Tomcat是一个开源的Java Servlet容器，广泛用于部署Java Web应用程序。 ...
PostgreSQL性能优化
最新发布
08-24
给大家分享一套课程——PostgreSQL性能优化。
应用性能优化
05-06
接口超时，服务器负载高...尤其是在“糙快猛”的互联网开发模式大行其道的今天，随着系统访问量的日益增加和代码的臃肿，各种性能问题开始纷至沓来。Java 应用性能的瓶颈点非常多，比如磁盘、内存、网络 I/O 等系统因素
性能优化PPT.pdf
03-21
### 性能优化的核心概念与实践 #### 一、什么是性能优化？ 性能优化是指通过一系列技术和方法提升系统或应用程序在处理任务时的速度、效率及稳定性等指标的过程。它旨在充分发挥硬件资源的优势，同时减少不必要的...
非UI线程处理Bitmap
qq_42795723的博客
11-05 102
在上一课中介绍了一系列的BitmapFactory.decode*方法，当图片来源是网络或者是存储卡时（或者是任何不在内存中的形式），这些方法都不应该在UI 线程中执行。因为在上述情况下加载数据时，其执行时间是不可估计的，它依赖于许多因素（从网络或者存储卡读取数据的速度，图片的大小，CPU的速度等）。如果其中任何一个子操作阻塞了UI线程，系统都会容易出现应用无响应的错误。 这一节课会介绍如何使用A...
高效显示Bitmap之UI线程外处理Bitmap
mzyl
11-23 540
如果数据源从硬盘读取或者网络， BitmapFactory.decode*方法不应该在main线程中执行。加载这些数据的时间是不可预知的，受限于多种因素（硬盘读取速度，图片大小，CPU等等）。如果任一因素锁住了UI线程，系统会标记你的APP无响应，用户会有选择关闭其操作（see Designing for Responsiveness for more information）。 这节课教你
android 异步图片加载 开源,异步加载图片BitmapFun分析
weixin_32655655的博客
05-29 170
博客地址：http://my.oschina.net/lifj/blog/313866--------2014年8月19日BY拉风的道长开源项目地址项目简介如果图片资源是静态的，当我们要在View上显示图片时，只需要简单的将图片赋值给ImageView就可以了，但如果需要浏览网络上的图片时该如何做呢？有可能图片很大，有可能网速很慢并且不稳定，这种情况下该如何增加用户体验。Android官方的Bi...
Android Bitmap大量使用不产生OOM之多线程并发加载Bitmap的处理方式
Shi_Liz的博客
08-06 3501
转载请注明 http://blog.csdn.net/sinat_30276961/article/details/47314787 上一篇讲了Android Bitmap大量使用不产生OOM之“加载大图片资源优化”，用到了BitmapFactory.decode* 这些解析方法，如果涉及到的图片源来自sd卡或者来自网络，就绝对不要在ui主线程执行。这些数据的加载所耗的时间是不确定的，有很多因
异步线程处理bitmap
珊瑚瞧的专栏
07-24 1302
高效加载大bitmap课程讨论过，当从磁盘或者网络读取数据(或者其他没有在内存的数据)时，不应该在主线程执行BitmapFactory.decode*方法。因为此时加载数据花费的时间是不确定的，依赖于很多因素(磁盘读取速度、网速、图片大小、或者CPUd的功率等等)，如果这些任务其中一个阻塞了UI线程，系统就会把应用标志为无响应，用户会有一个关闭它的选项(更多信息请参考响应性设计)这节课将会带领你使用
如何高效的展示Bitmap
还不走
07-24 2181
任何应用都逃脱不了图片展示，所以任何应用都逃脱不了Bitmap。既然逃脱不了，我决定一次性解决。本文内容源自 http://developer.android.com/intl/zh-cn/training/displaying-bitmaps/index.html ，官方的training课程，还带有一个S级别的范例，强烈推荐。为什么需要高效的展示开发面对大量图片处理的时候，bitmap如果处理不
Android混淆
liu_12345_liu的博客
10-30 4816
文章目录开启混淆ProGuard的作用混淆的基本规则 开启混淆 Android中配置混淆，需要在gradle中配置minifyEnabled为true，然后再混淆的配置文件中加入我们的混淆规则就可以。 android { ... buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android.txt'
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值