devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 性能优化之启动优化解析_启动性能优化

作者：Gausst松鼠会 | 2024-04-12 08:50:54

赞

踩

启动性能优化

应用启动分类：

  1. 冷启动：耗时最多、衡量标准。

    ClickEvent->IPC->Process.start->ActivityThread->bindApplication->LifeCycle->ViewRootImpl

  2. 热启动:最快，后台->前台

  3. 温启动：较快

冷启动的相关任务

  • 冷启动之前：

    启动App -> 加载空白Window-> 创建进程

  • 随后任务：

    创建Application -> 启动主线程 -> 创建入口Acitivity -> 加载布局 -> 布置屏幕 -> 首帧绘制

优化方向:

Application和Activity生命周期

1.1 启动时间测量方式

1.1.1 adb命令

adb shell am start -W packagename/首屏Activity

image.png

Status：ok（启动无异常） LaunchState：COLD（冷启动） Activity：.SplashActivity（目标Activity）

TotalTime：所有Activity启动耗时 ThisTime：最后一个Activity启动耗时 WaitTime：AMS启动Activity的总耗时

当前为application->SplashActivity，中间无中转Activity，因此TotalTime与ThisTime一致。

线下使用，不能带到线上 非严谨、精确时间

1.1.2 手动打点

启动时埋点，启动后结束埋点，二者差值即为启动时间。

从Application的attachBaseContext()为起点。

误区：以onWindowsFocusChanged为首帧时间，其实这个回调只是Activity的首帧时间，实际上并不代表已绘制至屏幕中。

正解：真实数据展示，Feed的第一条展示的时候作为结束时间。

public class StarTimeUtil {
    private static final String TAG = "StartUtil";
    static long startTime;
    static long time;

    public static void startRecord() {
        startTime = System.currentTimeMillis();
    }

    public static void endRecord() {
        time = System.currentTimeMillis() - startTime;
        Log.d(TAG, "耗时：" + time + "ms");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
@Override
protected void attachBaseContext(Context base) {
    StarTimeUtil.startRecord();
    MultiDex.install(this);
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
@Override
protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_splash);
    findViewById(R.id.fl).getViewTreeObserver().addOnDrawListener(onDrawListener);
}

ViewTreeObserver.OnDrawListener onDrawListener =  new ViewTreeObserver.OnDrawListener() {
    @Override
    public void onDraw() {
        StarTimeUtil.endRecord();
        findViewById(R.id.fl).post(new Runnable() {
            @Override
            public void run() {
                findViewById(R.id.fl).getViewTreeObserver().removeOnDrawListener(onDrawListener);
            }
        });
    }
};


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

image.png

精确，可带到线上，推荐使用。 注意避开误区，采用Feed第一条展示。 addOnDrawListener 要求 API16，版本低于16可选择使用addOnPreDrawListener。

1.2 启动优化工具选择

1.2.1 traceView

图形化展示执行时间、调用栈等，信息全面，包含所有线程。

缺点：运行时开销严重，程序整体变慢，可能会带偏优化方向。

使用方式：

Debug.startMethodTracing("");

Debug.stoptMethodTracing();

生成文件在sd卡：Android/data/packagename/files

image.png

image.png

WallClockTime：代码执行的所需时间，包括阻塞耗时如等待锁时

ThreadTime：CPU执行时间，CPU确实在该线程工作的时间

CallChart: 由上至下即是调用者到被调用者,橙色为系统api的调用，绿色为应用自身api的调用，蓝色为第三方api的调用

FlameChart: 收集重复调用的函数之类的

TopDown: 很清晰的函数调用列表，可右键跳转到详细代码中

Total：函数执行总时间

self：函数自身代码执行时间

Children：函数内部所调用函数的执行时间

Total=self+Children

BottomUp: 也是函数调用列表，只不过与TopDown的展示相反

TraceView是Android平台一个很好的性能分析的工具，能够以图形的形式显示跟踪日志，但是已弃用。另外TraceView的性能消耗太大，得到的结果不真实。

1.2.2 systrace

结合Android内核的数据，生成Html报告。

需要API18以上，推荐使用TraceCompat向下兼容。

轻量级，开销小，直观反映CPU利用率。

使用方式:

python环境

python systrace.py -t 10 [other-options] [categories]

python …/Library/Android/sdk/platform-tools/systrace/systrace.py -t 5 -a com.xxx.xxx.xxx -o performance.html sched gfx view wm am app

image.png

image.png

1.2.3 Systrace + 函数插桩

Systrace 允许你收集和检查设备上运行的所有进程的计时信息。它包括AndroidKernel的一些数据（例如CPU调度程序，IO和App Thread），并且会生成HTML报告，方便用户查看分析trace内容。但是不支持应用程序代码的耗时分析，如果需要分析程序代码的执行时间，那就要结合函数插桩的方式，对细节进行分析。

1.2.4 CPU Profiler

代替Traceview的，便是CPU Profiler。

它可以检查通过使用Debug类对应用进行插桩检测而捕获的.trace 文件、记录新方法跟踪信息、保存.trace 文件以及检查应用进程的实时CPU使用情况。

具体使用方式，与Traceview大同小异。

1.3 优雅获取方法耗时

1.3.1 常规方式（手动埋点）

long time = System.currentTimeMills();

long cost =System.currentTimeMills()-time;


  • 1
  • 2
  • 3
  • 4

或者

// cpu真正所耗时间
SystemClock.currentThreadTimeMills();


  • 1
  • 2
  • 3
long time = System.currentTimeMillis();
initThirdPart();
long cost = System.currentTimeMillis() - time;

time = System.currentTimeMillis();
initThirdPart();
cost = System.currentTimeMillis() - time;

time = System.currentTimeMillis();
initThirdPart();
cost = System.currentTimeMillis() - time;



  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这种常规获取方法耗时的方式就很不合理，侵入性强、工作量大。

1.3.2 AOP方式

Aspect Oriented Programing,面向切面编程。

应用场景：针对同一类问题的统一处理时。

优点：无侵入添加代码，修改简单。

使用AspectJ辅助实现

1.3.2.1 JoinPoints

程序运行时的执行点，可以作为切面的地方：

  • 函数调用、执行，获取
  • 设置变量
  • 类初始化
1.3.2.2 PointCut

带条件的JoinPoints

1.3.2.3 Advice

一种Hook，要插入代码的位置。

  • Before:PointCut之前执行

  • After:PointCut之后执行

  • Around：PointCut之前、之后分别执行。

  • execution：处理JoinPoint的类型：call、execution

onActivityCalled:要插入的代码。

@Aspect
public class PerformanceAop {
    @Around("call(* debug.DemoApplication.**(..))")
    public void getTime(ProceedingJoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String name = signature.toShortString();
        long time = System.currentTimeMillis();
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

//        LogUtils.i(name + " cost " + (System.currentTimeMillis() - time));
    }

    @Around("execution(* android.app.Activity.setContentView(..))")
    public void getSetContentViewTime(ProceedingJoinPoint joinPoint) {

        Signature signature = joinPoint.getSignature();
        String name = signature.toShortString();
        long time = System.currentTimeMillis();
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        LogUtils.i(name + " cost " + (System.currentTimeMillis() - time));
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

1.3 异步优化

核心思想：子线程分担主线程任务，并行减少时间.

需要注意：不符合异步优化的，需要在某阶段完成的，要区分CPU密集型和IO密集型任务。

常规初始化流程

public class DemoApplication extends BaseApplication {

    @Override
    public void onCreate() {
        super.onCreate();
        initThirdPart();
        initBugly();
    }

    private void initBugly() {

    }

    /**
     * 模拟为在Application中的初始化操作的耗时行为
     */
    private void initThirdPart() {

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            ToastUtils.showShortToast("第三方框架初始化耗时异常");
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

常规异步优化

public class DemoApplication extends BaseApplication {

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));

    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private CountDownLatch mCountDownLatch = new CountDownLatch(1);

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

//      关于异步优化，一个初始化对应一条线程效果更好，而有的初始化并不适合在子线程中进行，
//      比如Handler，当然也可以改造成可以在子线程进行初始化，但是有的只能在主线程中初始化
//      异步优化无法保证初始化的完成时机,若依然还是需要在子线程进行初始化，可以借助CountDownLatch完成

        ExecutorService executorService = Executors.newFixedThreadPool(CORE_POOL_SIZE);

        executorService.submit(new Runnable() {
            @Override
            public void run() {
                initThirdPart();
            }

        });

        executorService.submit(new Runnable() {

            @Override
            public void run() {
                initBugly();
                mCountDownLatch.countDown();//初始化完成

            }
        });
        mCountDownLatch.await();//等待条件满足

    }

    private void initBugly() {

    }

    /**
     * 模拟为在Application中的初始化操作的耗时行为
     */
    private void initThirdPart() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            ToastUtils.showShortToast("第三方框架初始化耗时异常");
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

1.4 异步优化最优解

常规异步的缺点：代码不优雅，场景不好处理（有的初始化任务会存在依赖关系），维护成本高

启动器优化

核心思想：充分利用CPU多核，自动梳理任务顺序

启动器流程：

  • 代码Task化，启动逻辑抽象为Task；
  • 根据所有任务依赖关系排序生成一个有向无环图；
  • 多线程按照排序后的优先级依次执行

image.png

主线程：相当于常规初始化

并发：相当于异步初始化

head task:主体task执行前的操作

tail task：主体task执行后的操作

ilde task：空闲时执行的操作

这三个task起到锦上添花的作用，可按需使用

        // 使用启动器的方式进行初始化优化
        TaskDispatcher.init(this);
        TaskDispatcher taskDispatcher = TaskDispatcher.createInstance();
        taskDispatcher.addTask(new InitBugly()).addTask(new InitThirdPartTask()).start();
        // 有的task需要等待完成
        taskDispatcher.await();


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.5 更优秀的延迟初始化

public interface OnFeedShowCallBack {
    void onFeedShow();
}


  • 1
  • 2
  • 3
  • 4
public class PerformanceOptimizationActivity extends BaseActivity implements OnFeedShowCallBack {
    ...
    ...
    ...

    @Override
    public void onFeedShow() {
        ...
        ...
        ...
        
        // 一系列操作 耗时十秒
        new DispatchRunnable(new DelayInitTaskA()).run();
        new DispatchRunnable(new DelayInitTaskB()).run();
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
public void onBindViewHolder(@NonNull final ViewHolder holder, int position) {
    ...
    ...
    ...

    if (position == 0 && !mHasRecorded) {
        mHasRecorded = true;
        holder.layout.getViewTreeObserver()
                .addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
                    @Override
                    public boolean onPreDraw() {
                        holder.layout.getViewTreeObserver().removeOnPreDrawListener(this);
                        LogUtils.i("FeedShow");
                        LaunchTimer.endRecord("FeedShow");
                        if (mCallBack != null) {
                            mCallBack.onFeedShow();
                        }
                        return true;
                    }
                });
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

针对以上场景时：

  1. 常规方案：

    new Handler().postDelayed,Feed展示后调用

    时机不便控制导致Feed卡顿

  2. 更优方案

    核心思想：对延迟任务进行分批初始化

    利用IdleHandler特性，空闲执行

    执行时机明确，缓解Feed卡顿

    public class PerformanceOptimizationActivity extends BaseActivity implements OnFeedShowCallBack {
    
    ...
    ...
    ...

    @Override
    public void onFeedShow() {
        DelayInitDispatcher delayInitDispatcher = new DelayInitDispatcher();
        delayInitDispatcher.addTask(new DelayInitTaskA()).addTask(new DelayInitTaskB()).start();
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

1.6 全民视觉优化

在用户点击手机桌面APP的时候，看到的黑屏或者白屏其实是界面渲染前的第一帧，解决这个问题非常轻松，无非就是将Theme里的windowBackground设置成我们想要让用户看到的画面就可以了，这里有2种做法：

1.将背景图设置成APP的Logo图，作为APP启动的引导，现在市面上大部分的APP也是这么做的。

<style name="AppWelcome" parent="AppTheme">
<item name="android:windowBackground">@mipmap/bg_welcome_start</item>
</style>


  • 1
  • 2
  • 3
  • 4

2.将背景颜色设置为透明色，这样当用户点击桌面APP图片的时候，并不会"立即"进入APP，而且在桌面上停留一会，其实这时候APP已经是启动的了，只是我们心机的把Theme里的windowBackground的颜色设置成透明的，强行把锅甩给了手机应用厂商。

<style name="Appwelcome" parent="android:Theme.Translucent.NoTitleBar.Fullscreen"/>


  • 1
  • 2

透明化这种做法需要注意的一点，如果直接把Theme引入Activity，在运行的时候可能会出现如下异常：

java.lang.IllegalStateException: You need to use a Theme.AppCompat theme (or descendant) with this activity.

这个是因为使用了不兼容的Theme，例如我这里的Activity继承了AppCompatActivity，解决方案很简单： 1、让其Activity集成Activity而不要集成兼容性的AppCompatActivity 2、在onCreate()方法里的super.onCreate(savedInstanceState)之前设置我们原来APP的Theme。

public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
setTheme(R.style.AppTheme);
super.onCreate(savedInstanceState);
}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

1.7 启动优化的其它方案

优化总方针：异步、延迟、懒加载，技术、业务相结合。

收敛启动代码的的修改权限：结合CI，修改启动代码需要Review或通知，防止维护好的启动启动代码被破坏。

  1. 提前加载SharedPreferences

    SharedPreferences是IO操作，可在Multidex之前加载，利用此阶段的CPU，此时的CPU是肯定尚未跑满的。SharedPreferences是系统类，在这之前提前加载初始化SharedPreferences不会有异常，是少有的可以在Multidex之前加载优化的类。

    覆写getApplicationContext()，返回this。

  2. 启动阶段不启动子进程

    子进程会共享CPU资源。

    注意启动顺序:App onCreate之前是ContentProvider。

  3. 类加载优化：提前异步类加载

    Class.forName()只加载类本身及其静态变量引用类。

    new 类实例，可以额外加载类成员变量的引用类。

  4. 启动阶段抑制GC

  5. CPU锁频

2. 造火箭攻略

2.1 自问自答

你的启动优化是怎么做的？

是启动优化的负责人

分析现状、确认问题

比如启动速度的监听、竞品分析

针对性优化：思路从小到大

长期保持优化效果：启动器代码的封装；收敛启动代码的修改权限

是怎么异步的，异步遇到问题没有？

体现演进过程：线程池->启动器

详细介绍启动器

你做了启动优化，觉得有哪些容易忽略的注意点？

cpu time与wall time的区别，cpu time是优化方向

注意延迟初始化的优化：不用常规方式，用idleHandler

介绍下黑科技：类加载，抑制GC，CPU锁频

版本迭代导致的启动变慢，有好的解决方式吗？

启动器

结合CI

新加代码后，上线前就先及时测量启动速度，监控完善

2.2 Baseline Profiles

3. 拧螺丝攻略

3.1 启动优化预备知识

3.1.1 Wall Duration 与 CPU Duration

image.png

Wall Duration:代码执行时间 CPU Duration:代码消耗CUP的时间（重点指标，优化方向）

比如锁的冲突：线程执行的方法本身也许并不耗时，但是由于要等待锁的释放，而这便会加长代码的执行时间，等待锁处于阻塞的过程，CPU并不会在在该线程的方法上消耗时间。

3.1.2 adb命令

获取当前APP的包名类名： adb shell "dumpsys window | grep mCurrentFocus

adb启动指定activity： adb shell am start -W [包名]/[类名]

adb shell am start -S -R 5-W [包名]/[类名]

-S:表示每次启动前先强行停止

-R:表示重复测试次数

adb查看相关进程信息（模糊匹配）： adb shell "ps|grep [模糊匹配进程名]"

adb杀死进程： adb shell kill [PID]/adb shell am force-stop [包名]

3.2 启动器源码

3.2.1 排序算法

/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc 有向无环图的拓扑排序算法
 */
public class Graph {
    //顶点数
    private int mVerticeCount;
    //邻接表
    private List<Integer>[] mAdj;

    public Graph(int verticeCount) {
        this.mVerticeCount = verticeCount;
        mAdj = new ArrayList[mVerticeCount];
        for (int i = 0; i < mVerticeCount; i++) {
            mAdj[i] = new ArrayList<Integer>();
        }
    }

    /**
     * 添加边
     *
     * @param u from
     * @param v to
     */
    public void addEdge(int u, int v) {
        mAdj[u].add(v);
    }

    /**
     * 拓扑排序
     */
    public Vector<Integer> topologicalSort() {
        int indegree[] = new int[mVerticeCount];
        for (int i = 0; i < mVerticeCount; i++) {//初始化所有点的入度数量
            ArrayList<Integer> temp = (ArrayList<Integer>) mAdj[i];
            for (int node : temp) {
                indegree[node]++;
            }
        }
        Queue<Integer> queue = new LinkedList<Integer>();
        for (int i = 0; i < mVerticeCount; i++) {//找出所有入度为0的点
            if (indegree[i] == 0) {
                queue.add(i);
            }
        }
        int cnt = 0;
        Vector<Integer> topOrder = new Vector<Integer>();
        while (!queue.isEmpty()) {
            int u = queue.poll();
            topOrder.add(u);
            for (int node : mAdj[u]) {//找到该点（入度为0）的所有邻接点
                if (--indegree[node] == 0) {//把这个点的入度减一，如果入度变成了0，那么添加到入度0的队列里
                    queue.add(node);
                }
            }
            cnt++;
        }
        if (cnt != mVerticeCount) {//检查是否有环，理论上拿出来的点的次数和点的数量应该一致，如果不一致，说明有环
            throw new IllegalStateException("Exists a cycle in the graph");
        }
        return topOrder;
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc 有向无环图的拓扑排序算法
 */
public class TaskSortUtil {

    private static List<Task> sNewTasksHigh = new ArrayList<>();// 高优先级的Task

    /**
     * 任务的有向无环图的拓扑排序
     *
     * @return
     */
    public static synchronized List<Task> getSortResult(List<Task> originTasks,
                                                        List<Class<? extends Task>> clsLaunchTasks) {
        long makeTime = System.currentTimeMillis();

        Set<Integer> dependSet = new ArraySet<>();
        Graph graph = new Graph(originTasks.size());
        for (int i = 0; i < originTasks.size(); i++) {
            Task task = originTasks.get(i);
            if (task.isSend() || task.dependsOn() == null || task.dependsOn().size() == 0) {
                continue;
            }
            for (Class cls : task.dependsOn()) {
                int indexOfDepend = getIndexOfTask(originTasks, clsLaunchTasks, cls);
                if (indexOfDepend < 0) {
                    throw new IllegalStateException(task.getClass().getSimpleName() +
                            " depends on " + cls.getSimpleName() + " can not be found in task list ");
                }
                dependSet.add(indexOfDepend);
                graph.addEdge(indexOfDepend, i);
            }
        }
        List<Integer> indexList = graph.topologicalSort();
        List<Task> newTasksAll = getResultTasks(originTasks, dependSet, indexList);

        DispatcherLog.i("task analyse cost makeTime " + (System.currentTimeMillis() - makeTime));
        printAllTaskName(newTasksAll);
        return newTasksAll;
    }

    @NonNull
    private static List<Task> getResultTasks(List<Task> originTasks,
                                             Set<Integer> dependSet, List<Integer> indexList) {
        List<Task> newTasksAll = new ArrayList<>(originTasks.size());
        List<Task> newTasksDepended = new ArrayList<>();// 被别人依赖的
        List<Task> newTasksWithOutDepend = new ArrayList<>();// 没有依赖的
        List<Task> newTasksRunAsSoon = new ArrayList<>();// 需要提升自己优先级的，先执行（这个先是相对于没有依赖的先）
        for (int index : indexList) {
            if (dependSet.contains(index)) {
                newTasksDepended.add(originTasks.get(index));
            } else {
                Task task = originTasks.get(index);
                if (task.needRunAsSoon()) {
                    newTasksRunAsSoon.add(task);
                } else {
                    newTasksWithOutDepend.add(task);
                }
            }
        }
        // 顺序：被别人依赖的————》需要提升自己优先级的————》需要被等待的————》没有依赖的
        sNewTasksHigh.addAll(newTasksDepended);
        sNewTasksHigh.addAll(newTasksRunAsSoon);
        newTasksAll.addAll(sNewTasksHigh);
        newTasksAll.addAll(newTasksWithOutDepend);
        return newTasksAll;
    }

    private static void printAllTaskName(List<Task> newTasksAll) {
        if (true) {
            return;
        }
        for (Task task : newTasksAll) {
            DispatcherLog.i(task.getClass().getSimpleName());
        }
    }

    public static List<Task> getTasksHigh() {
        return sNewTasksHigh;
    }

    /**
     * 获取任务在任务列表中的index
     *
     * @param originTasks
     * @param
     * @return
     */
    private static int getIndexOfTask(List<Task> originTasks,
                                      List<Class<? extends Task>> clsLaunchTasks, Class cls) {
        int index = clsLaunchTasks.indexOf(cls);
        if (index >= 0) {
            return index;
        }

        // 仅仅是保护性代码
        final int size = originTasks.size();
        for (int i = 0; i < size; i++) {
            if (cls.getSimpleName().equals(originTasks.get(i).getClass().getSimpleName())) {
                return i;
            }
        }
        return index;
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108

3.2.2 启动Task抽象化

/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public interface ITask {

    /**
     * 优先级的范围，可根据Task重要程度及工作量指定；之后根据实际情况决定是否有必要放更大
     *
     * @return
     */
    @IntRange(from = Process.THREAD_PRIORITY_FOREGROUND, to = Process.THREAD_PRIORITY_LOWEST)
    int priority();

    void run();

    /**
     * Task执行所在的线程池，可指定，一般默认
     *
     * @return
     */
    Executor runOn();

    /**
     * 依赖关系
     *
     * @return
     */
    List<Class<? extends Task>> dependsOn();

    /**
     * 异步线程执行的Task是否需要在被调用await的时候等待，默认不需要
     *
     * @return
     */
    boolean needWait();

    /**
     * 是否在主线程执行
     *
     * @return
     */
    boolean runOnMainThread();

    /**
     * 只是在主进程执行
     *
     * @return
     */
    boolean onlyInMainProcess();

    /**
     * Task主任务执行完成之后需要执行的任务
     *
     * @return
     */
    Runnable getTailRunnable();

    void setTaskCallBack(TaskCallBack callBack);

    boolean needCall();
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public abstract class Task implements ITask {
    protected String mTag = getClass().getSimpleName().toString();
    protected Context mContext = TaskDispatcher.getContext();
    protected boolean mIsMainProcess = TaskDispatcher.isMainProcess();// 当前进程是否是主进程
    private volatile boolean mIsWaiting;// 是否正在等待
    private volatile boolean mIsRunning;// 是否正在执行
    private volatile boolean mIsFinished;// Task是否执行完成
    private volatile boolean mIsSend;// Task是否已经被分发
    private CountDownLatch mDepends = new CountDownLatch(dependsOn() == null ? 0 : dependsOn().size());// 当前Task依赖的Task数量（需要等待被依赖的Task执行完毕才能执行自己），默认没有依赖

    /**
     * 当前Task等待，让依赖的Task先执行
     */
    public void waitToSatisfy() {
        try {
            mDepends.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 依赖的Task执行完一个
     */
    public void satisfy() {
        mDepends.countDown();
    }

    /**
     * 是否需要尽快执行，解决特殊场景的问题：一个Task耗时非常多但是优先级却一般，很有可能开始的时间较晚，
     * 导致最后只是在等它，这种可以早开始。
     *
     * @return
     */
    public boolean needRunAsSoon() {
        return false;
    }

    /**
     * Task的优先级，运行在主线程则不要去改优先级
     *
     * @return
     */
    @Override
    public int priority() {
        return Process.THREAD_PRIORITY_BACKGROUND;
    }

    /**
     * Task执行在哪个线程池，默认在IO的线程池；
     * CPU 密集型的一定要切换到DispatcherExecutor.getCPUExecutor();
     *
     * @return
     */
    @Override
    public ExecutorService runOn() {
        return DispatcherExecutor.getIOExecutor();
    }

    /**
     * 异步线程执行的Task是否需要在被调用await的时候等待，默认不需要
     *
     * @return
     */
    @Override
    public boolean needWait() {
        return false;
    }

    /**
     * 当前Task依赖的Task集合（需要等待被依赖的Task执行完毕才能执行自己），默认没有依赖
     *
     * @return
     */
    @Override
    public List<Class<? extends Task>> dependsOn() {
        return null;
    }

    @Override
    public boolean runOnMainThread() {
        return false;
    }

    @Override
    public Runnable getTailRunnable() {
        return null;
    }

    @Override
    public void setTaskCallBack(TaskCallBack callBack) {}

    @Override
    public boolean needCall() {
        return false;
    }

    /**
     * 是否只在主进程，默认是
     *
     * @return
     */
    @Override
    public boolean onlyInMainProcess() {
        return true;
    }

    public boolean isRunning() {
        return mIsRunning;
    }

    public void setRunning(boolean mIsRunning) {
        this.mIsRunning = mIsRunning;
    }

    public boolean isFinished() {
        return mIsFinished;
    }

    public void setFinished(boolean finished) {
        mIsFinished = finished;
    }

    public boolean isSend() {
        return mIsSend;
    }

    public void setSend(boolean send) {
        mIsSend = send;
    }

    public boolean isWaiting() {
        return mIsWaiting;
    }

    public void setWaiting(boolean mIsWaiting) {
        this.mIsWaiting = mIsWaiting;
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public abstract class MainTask extends Task {

    @Override
    public boolean runOnMainThread() {
        return true;
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc 任务真正执行的地方
 */
public class DispatchRunnable implements Runnable {
    private Task mTask;
    private TaskDispatcher mTaskDispatcher;

    public DispatchRunnable(Task task) {
        this.mTask = task;
    }
    public DispatchRunnable(Task task,TaskDispatcher dispatcher) {
        this.mTask = task;
        this.mTaskDispatcher = dispatcher;
    }

    @Override
    public void run() {
//        TraceCompat.beginSection(mTask.getClass().getSimpleName());
        DispatcherLog.i(mTask.getClass().getSimpleName()
                + " begin run" + "  Situation  " + TaskStat.getCurrentSituation());

        Process.setThreadPriority(mTask.priority());

        long startTime = System.currentTimeMillis();

        mTask.setWaiting(true);
        mTask.waitToSatisfy();

        long waitTime = System.currentTimeMillis() - startTime;
        startTime = System.currentTimeMillis();

        // 执行Task
        mTask.setRunning(true);
        mTask.run();

        // 执行Task的尾部任务
        Runnable tailRunnable = mTask.getTailRunnable();
        if (tailRunnable != null) {
            tailRunnable.run();
        }

        if (!mTask.needCall() || !mTask.runOnMainThread()) {
            printTaskLog(startTime, waitTime);

            TaskStat.markTaskDone();
            mTask.setFinished(true);
            if(mTaskDispatcher != null){
                mTaskDispatcher.satisfyChildren(mTask);
                mTaskDispatcher.markTaskDone(mTask);
            }
            DispatcherLog.i(mTask.getClass().getSimpleName() + " finish");
        }
//        TraceCompat.endSection();
    }

    /**
     * 打印出来Task执行的日志
     *
     * @param startTime
     * @param waitTime
     */
    private void printTaskLog(long startTime, long waitTime) {
        long runTime = System.currentTimeMillis() - startTime;
        if (DispatcherLog.isDebug()) {
            DispatcherLog.i(mTask.getClass().getSimpleName() + "  wait " + waitTime + "    run "
                    + runTime + "   isMain " + (Looper.getMainLooper() == Looper.myLooper())
                    + "  needWait " + (mTask.needWait() || (Looper.getMainLooper() == Looper.myLooper()))
                    + "  ThreadId " + Thread.currentThread().getId()
                    + "  ThreadName " + Thread.currentThread().getName()
                    + "  Situation  " + TaskStat.getCurrentSituation()
            );
        }
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public interface TaskCallBack {

    void call();
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3.3.3 启动器线程池

/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public class DispatcherExecutor {
    private static ThreadPoolExecutor sCPUThreadPoolExecutor;
    private static ExecutorService sIOThreadPoolExecutor;

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work

    public static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 5));
    private static final int MAXIMUM_POOL_SIZE = CORE_POOL_SIZE;
    private static final int KEEP_ALIVE_SECONDS = 5;
    private static final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<>();
    private static final DefaultThreadFactory sThreadFactory = new DefaultThreadFactory();
    private static final RejectedExecutionHandler sHandler = new RejectedExecutionHandler() {// 一般不会到这里
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            Executors.newCachedThreadPool().execute(r);
        }
    };

    /**
     * 获取CPU线程池
     * @return
     */
    public static ThreadPoolExecutor getCPUExecutor() {
        return sCPUThreadPoolExecutor;
    }

    /**
     * 获取IO线程池
     * @return
     */
    public static ExecutorService getIOExecutor() {
        return sIOThreadPoolExecutor;
    }

    /**
     * The default thread factory.
     */
    private static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = "TaskDispatcherPool-" +
                    poolNumber.getAndIncrement() +
                    "-Thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    static {
        sCPUThreadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory, sHandler);
        sCPUThreadPoolExecutor.allowCoreThreadTimeOut(true);
        sIOThreadPoolExecutor = Executors.newCachedThreadPool(sThreadFactory);
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public class DispatcherLog {
    private static final String TAG = DispatcherLog.class.getSimpleName();

    private static boolean sDebug = false;

    public static void i(String msg) {
        if (!sDebug) {
            return;
        }
        Log.i(TAG,msg);
    }

    public static boolean isDebug() {
        return sDebug;
    }

    public static void setDebug(boolean debug) {
        sDebug = debug;
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3.3.4 启动统计

/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
class TaskStatBean {

    private String situation;
    private int count;

    public String getSituation() {
        return situation;
    }

    public void setSituation(String situation) {
        this.situation = situation;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public class TaskStat {

    private static volatile String sCurrentSituation = "";
    private static List<TaskStatBean> sBeans = new ArrayList<>();
    private static AtomicInteger sTaskDoneCount = new AtomicInteger();
    private static boolean sOpenLaunchStat = false;// 是否开启统计

    public static String getCurrentSituation() {
        return sCurrentSituation;
    }

    public static void setCurrentSituation(String currentSituation) {
        if (!sOpenLaunchStat) {
            return;
        }
        DispatcherLog.i("currentSituation   " + currentSituation);
        sCurrentSituation = currentSituation;
        setLaunchStat();
    }

    public static void markTaskDone() {
        sTaskDoneCount.getAndIncrement();
    }

    public static void setLaunchStat() {
        TaskStatBean bean = new TaskStatBean();
        bean.setSituation(sCurrentSituation);
        bean.setCount(sTaskDoneCount.get());
        sBeans.add(bean);
        sTaskDoneCount = new AtomicInteger(0);
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

3.3.5 启动器

/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc 启动器调用类
 */
public class TaskDispatcher {
    private long mStartTime;
    private static final int WAITTIME = 10000;
    private static Context sContext;
    private static boolean sIsMainProcess;
    private List<Future> mFutures = new ArrayList<>();
    private static volatile boolean sHasInit;
    private List<Task> mAllTasks = new ArrayList<>();
    private List<Class<? extends Task>> mClsAllTasks = new ArrayList<>();
    private volatile List<Task> mMainThreadTasks = new ArrayList<>();
    private CountDownLatch mCountDownLatch;
    private AtomicInteger mNeedWaitCount = new AtomicInteger();//保存需要Wait的Task的数量
    private List<Task> mNeedWaitTasks = new ArrayList<>();//调用了await的时候还没结束的且需要等待的Task
    private volatile List<Class<? extends Task>> mFinishedTasks = new ArrayList<>(100);//已经结束了的Task
    private HashMap<Class<? extends Task>, ArrayList<Task>> mDependedHashMap = new HashMap<>();
    private AtomicInteger mAnalyseCount = new AtomicInteger();//启动器分析的次数，统计下分析的耗时；

    private TaskDispatcher() {
    }

    public static void init(Context context) {
        if (context != null) {
            sContext = context;
            sHasInit = true;
            sIsMainProcess = SystemUtils.isMainProcess();
        }
    }

    /**
     * 注意：每次获取的都是新对象
     *
     * @return
     */
    public static TaskDispatcher createInstance() {
        if (!sHasInit) {
            throw new RuntimeException("must call TaskDispatcher.init first");
        }
        return new TaskDispatcher();
    }

    public TaskDispatcher addTask(Task task) {
        if (task != null) {
            collectDepends(task);
            mAllTasks.add(task);
            mClsAllTasks.add(task.getClass());
            // 非主线程且需要wait的，主线程不需要CountDownLatch也是同步的
            if (ifNeedWait(task)) {
                mNeedWaitTasks.add(task);
                mNeedWaitCount.getAndIncrement();
            }
        }
        return this;
    }

    private void collectDepends(Task task) {
        if (task.dependsOn() != null && task.dependsOn().size() > 0) {
            for (Class<? extends Task> cls : task.dependsOn()) {
                if (mDependedHashMap.get(cls) == null) {
                    mDependedHashMap.put(cls, new ArrayList<Task>());
                }
                mDependedHashMap.get(cls).add(task);
                if (mFinishedTasks.contains(cls)) {
                    task.satisfy();
                }
            }
        }
    }

    private boolean ifNeedWait(Task task) {
        return !task.runOnMainThread() && task.needWait();
    }

    @UiThread
    public void start() {
        mStartTime = System.currentTimeMillis();
        if (Looper.getMainLooper() != Looper.myLooper()) {
            throw new RuntimeException("must be called from UiThread");
        }
        if (mAllTasks.size() > 0) {
            mAnalyseCount.getAndIncrement();
            printDependedMsg();
            mAllTasks = TaskSortUtil.getSortResult(mAllTasks, mClsAllTasks);
            mCountDownLatch = new CountDownLatch(mNeedWaitCount.get());

            sendAndExecuteAsyncTasks();

            DispatcherLog.i("task analyse cost " + (System.currentTimeMillis() - mStartTime) + "  begin main ");
            executeTaskMain();
        }
        DispatcherLog.i("task analyse cost startTime cost " + (System.currentTimeMillis() - mStartTime));
    }

    public void cancel() {
        for (Future future : mFutures) {
            future.cancel(true);
        }
    }

    private void executeTaskMain() {
        mStartTime = System.currentTimeMillis();
        for (Task task : mMainThreadTasks) {
            long time = System.currentTimeMillis();
            new DispatchRunnable(task,this).run();
            DispatcherLog.i("real main " + task.getClass().getSimpleName() + " cost   " +
                    (System.currentTimeMillis() - time));
        }
        DispatcherLog.i("maintask cost " + (System.currentTimeMillis() - mStartTime));
    }

    private void sendAndExecuteAsyncTasks() {
        for (Task task : mAllTasks) {
            if (task.onlyInMainProcess() && !sIsMainProcess) {
                markTaskDone(task);
            } else {
                sendTaskReal(task);
            }
            task.setSend(true);
        }
    }

    /**
     * 查看被依赖的信息
     */
    private void printDependedMsg() {
        DispatcherLog.i("needWait size : " + (mNeedWaitCount.get()));
        if (false) {
            for (Class<? extends Task> cls : mDependedHashMap.keySet()) {
                DispatcherLog.i("cls " + cls.getSimpleName() + "   " + mDependedHashMap.get(cls).size());
                for (Task task : mDependedHashMap.get(cls)) {
                    DispatcherLog.i("cls       " + task.getClass().getSimpleName());
                }
            }
        }
    }

    /**
     * 通知Children一个前置任务已完成
     *
     * @param launchTask
     */
    public void satisfyChildren(Task launchTask) {
        ArrayList<Task> arrayList = mDependedHashMap.get(launchTask.getClass());
        if (arrayList != null && arrayList.size() > 0) {
            for (Task task : arrayList) {
                task.satisfy();
            }
        }
    }

    public void markTaskDone(Task task) {
        if (ifNeedWait(task)) {
            mFinishedTasks.add(task.getClass());
            mNeedWaitTasks.remove(task);
            mCountDownLatch.countDown();
            mNeedWaitCount.getAndDecrement();
        }
    }

    private void sendTaskReal(final Task task) {
        if (task.runOnMainThread()) {
            mMainThreadTasks.add(task);

            if (task.needCall()) {
                task.setTaskCallBack(new TaskCallBack() {
                    @Override
                    public void call() {
                        TaskStat.markTaskDone();
                        task.setFinished(true);
                        satisfyChildren(task);
                        markTaskDone(task);
                        DispatcherLog.i(task.getClass().getSimpleName() + " finish");
                    }
                });
            }
        } else {
            // 直接发，是否执行取决于具体线程池
            Future future = task.runOn().submit(new DispatchRunnable(task,this));
            mFutures.add(future);
        }
    }

    public void executeTask(Task task) {
        if (ifNeedWait(task)) {
            mNeedWaitCount.getAndIncrement();
        }
        task.runOn().execute(new DispatchRunnable(task,this));
    }

    @UiThread
    public void await() {
        try {
            if (DispatcherLog.isDebug()) {
                DispatcherLog.i("still has " + mNeedWaitCount.get());
                for (Task task : mNeedWaitTasks) {
                    DispatcherLog.i("needWait: " + task.getClass().getSimpleName());
                }
            }

            if (mNeedWaitCount.get() > 0) {
                mCountDownLatch.await(WAITTIME, TimeUnit.MILLISECONDS);
            }
        } catch (InterruptedException e) {
        }
    }

    public static Context getContext() {
        return sContext;
    }

    public static boolean isMainProcess() {
        return sIsMainProcess;
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
/**
 * @author Huadao
 * @date Created in 2022/4/28
 * @desc
 */
public class DelayInitDispatcher {

    private Queue<Task> mDelayTasks = new LinkedList<>();

    private MessageQueue.IdleHandler mIdleHandler = new MessageQueue.IdleHandler() {
        @Override
        public boolean queueIdle() {
            if(mDelayTasks.size()>0){
                Task task = mDelayTasks.poll();
                new DispatchRunnable(task).run();
            }
            return !mDelayTasks.isEmpty();
        }
    };

    public DelayInitDispatcher addTask(Task task){
        mDelayTasks.add(task);
        return this;
    }

    public void start(){
        Looper.myQueue().addIdleHandler(mIdleHandler);
    }

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

链接：https://juejin.cn/post/7096013265179770910
作者：复制粘贴改改改

这里给大家分享一份《Android性能优化-大厂实战全解析》，这份《Android性能优化-大厂实战全解析》包括有：腾讯、字节、阿里、百度、网易、美团等一线互联网大厂的优化实战解析，更是附赠360°性能调优学习指南，有需要的朋友们也可以下载下来随时查漏补缺。扫二维码直接领取

图片

资料获取:

文末扫码二维码即可免费领取！

《‍Android性能优化-大厂实战全解析》目录及内容展示

腾讯团队

  • 腾讯光影研究室—Android P之Smart Linkify
  • 腾讯微信—Matrix原理分析系列之开篇
  • 腾讯微信—Mareix源码系列之如何解析应用安装包
  • 腾讯微信—Mareix源码系列之如何监控帧率变化
  • 腾讯Bugly—动态下发 so 库在 Android APK 安装包瘦身方面的应用
  • QQ音乐—彻底弄懂浏览器缓存策略
  • QQ音乐Android编译提速之路
  • 全民k歌适配arm64-v8a方案
  • 全民K歌内存篇1——线上监控与综合治理
  • 全民K歌内存篇2——虚拟内存浅析
  • 全民K歌内存篇3——native内存分析与监控
  • 腾讯Bugly—对字符串匹配算法的一点理解
  • …

图片

字节团队

  • 字节跳动技术团队— 深入理解Gradle框架之一：Plugin,Extension, buildSrc

  • 字节跳动技术团队—深入理解gradle框架之二：依赖实现分析

  • 字节跳动技术团队—Scene：Android 开源页面导航和组合框架

  • 字节跳动技术团队—AwCookieManager.nativeGetCookiecrash 排查

  • 字节跳动技术团队—另类 BadTokenException 问题分析和解决

  • 字节跳动技术团队—抖音包大小优化-资源优化

  • 字节跳动技术团队—二维码扫描优化

  • 字节跳动—Android Camera内存问题剖析

  • 抖音BoostMultiDex优化实践：Android低版本上APP首次启动时间减少80%

  • 抖音BoostMultiDex优化实践：Android低版本上APP首次启动时间减少80%（二）

  • 抖音 Android 性能优化系列：Java 内存优化篇

  • 今日头条 Android ‘秒’ 级编译速度优化

  • …

图片

阿里团队

  • 支付宝客户端架构解析：Android 客户端启动速度优化之「垃圾回收」

  • 支付宝 App 构建优化解析：通过安装包重排布优化 Android 端启动性能

  • 支付宝 App 构建优化解析：Android 包大小极致压缩

  • 解决支付宝包体积优化的遗留问题：运行时获取dexpc

  • 闲鱼技术—曾梦想 if-else 走天涯？看看“责任树模式”优化

  • 闲鱼如何在2个月内实现Android启动速度翻倍的？

  • 高德技术—Android Native 内存泄漏系统化解决方案

  • 天猫精灵技术—史上最全Android渲染机制讲解（长文源码深度剖析）

  • …

图片

百度团队

  • 百度APP-Android H5首屏优化实践

  • 百度App技术—一种简单优雅的TextView行间距适配方案

  • 百度App技术—Android 10分区存储介绍及百度APP适配实践

  • 百度App技术—Gradle 与 Android 构建入门

  • 百度App组件化之路

  • 百度App网络深度优化系列《三》弱网优化

  • …

图片

网易团队

  • 网易新闻客户端 H5 秒开优化

  • 网易新闻构建优化：如何让你的构建速度“势如闪电”

  • 网易传媒技术团队—AOP技术在客户端的应用与实践

  • 网易大数据|互联网产品决策秘笈: AB测试

  • …

图片

美团团队

  • 美团技术团队—Android静态代码扫描效率优化与实践

  • 美团技术团队—Probe：Android线上OOM问题定位组件

  • 美团技术团队—移动端UI一致性解决方案

  • 美团—设计稿（UI视图）自动生成代码方案的探索

  • ……

  • ……

图片

资料获取

文末扫码二维码即可免费领取！

《360°全方面性能调优》目录及内容展示

图片

第一章 设计思想与代码质量优化

1.六大原则

  • 单一职责原则
  • 里氏替换原则
  • 依赖倒转原则
  • 接口隔离原则
  • ……

2.设计模式

  • 结构型模式：桥接模式、适配器模式、装饰器模式、代理模式、门面（外观）模式……

  • 创建型模式：建造者模式、单例模式、抽象工厂模式、工厂方法模式……

  • 数据结构：数组、栈、队列、链表、树……

  • 算法：排序算法、查找算法……

    图片

第二章 程序性能优化

1.启动速度与执行效率优化

  • 冷启动和热启动解析
  • APP 启动黑白屏解决办法
  • APP 卡顿问题分析及解决方案
  • 启动速度与执行效率优化之 StrictMode
  • ……

2.布局检测与优化

  • 布局层级优化
  • 过度渲染
  • ……

3.内存优化

  • 内存抖动和内存泄漏
  • 内存大户
  • Bitmap 内存优化
  • Profile 内存监测工具
  • Mat 大对象与泄漏检测
  • 耗电优化
  • 网络传输与数据存储优化网络传输与数据存储优化
  • APK 大小优化
  • 屏幕适配
  • ……

4.耗电优化

  • Doze&Standby
  • Battery Historian
  • JobScheduler
  • WorkManager

5.网络传输与数据存储优化

  • google 序列化工具 protobuf
  • 7z 极限压缩
  • ……

6.APK 大小优化

  • APK 瘦身
  • 微信资源混淆原理
  • ……

图片

7.屏幕适配

进行适配的原理

屏幕分辨率限定符与 smallestWidth 限定符适配原理

为什么选择 smallestWidth 限定符适配

怎么适配其他 module

常见问题处理

…

8.OOM 问题原理解析

  • adj 内存管理机制
  • JVM 内存回收机制与 GC 算法解析
  • 生命周期相关问题总结
  • Bitmap 压缩方案总结
  • ……

9.ANR 问题解析

  • AMS 系统时间调节原理
  • 程序等待原理分析
  • ANR 问题解决方案
  • ……

10.Crash 监控方案

  • Java 层监控方案
  • Nativie 层监控方案
  • ……

图片

第三章 开发效率优化

1.分布式版本控制系统 Git

  • 企业高效持续集成平台场景介绍
  • GIT 分布式版本控制系统
  • GIT 分支管理
  • ……

2.自动化构建系统 Gradle：

  • Gradle 与 Android 插件：gradle 与 android gradle 插件的关系、Gradle Transform API 的基本使用……
  • Gradle Transform API 的基本使用：什么是 Transform、Transform 的使用场景、Transform API 学习、输入的类型……
  • 自定义插件开发：Gradle 插件简介、开始准备、实践、自定义 Gradle 插件、buildSrc 模块方式……
  • 插件实战：多渠道打包、发版自动钉钉……

图片

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/409973
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号