新闻类App （MVP + RxJava + Retrofit+

Github地址：新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）

线程调度原理

• 任意时刻，只有一个线程调用CPU，处于运行时状态
• 多线程并发：轮流获取CPU使用权
• JVM负责线程调度：按照特定机制分配CPU使用权

线程调度模型

• 分时调度模型：轮流获取，均分cpu时间
• (java虚拟机采用)抢占式调度模型：优先级高的获取

Android线程调度

nice值

• process中定义的
• 值越小，优先级越高

• 默认是THREAD_PRIORITY_DEFAULT =0

  
  优先级.png

cgroup

• 更严格的群组(前台和后台)调度策略
• 保证前台线程可以获取到更多的cpu
  哪些线程会移动到后台group：1.手动设置优先级低的 2.不在前台运行的应用程序的线程

1.线程过多会导致CPU切换频繁，降低线程运行效率
2.正确认识任务重要性j决定哪种优先级
3.优先级具有继承性

android异步方式汇总

Thread

• 最简单，最常见的异步方式(最不推荐)
• 不易复用，频繁创建及销毁开销大
• 复杂场景不易使用

HandlerThread

• 自带消息循环的线程
• 串行执行
• 长时间运行，不断从队列中获取任务

IntentService

• 继承自Service在内部创建HandlerThread
• 异步，不占用主线程
• 优先级较高，不易轻易被kill

AsyncTask

• android提供的工具类
• 无需自己处理线程
• 需注意版本不一致问题

线程池

• java提供的线程池
• 易复用减少频繁创建，销毁的时间
• 功能强大：定时，任务队列，并发数控制等

Rxjava

• 由强大的Scheduler集合提供
• 不同类型的区分：IO，Computation

Android线程优化实战

异步使用规则

• 严禁直接new Thread
• 提供基础线程池供各个业务线使用
  避免各个业务线各自维护一套线程池，导致线程数过多
• 根据任务类型选择合适的异步方式
• 创建线程必须命名
  方便定位线程归属
  运行期Thread.currentThread.setName修改名字
• 关键异步任务监控
  异步不等于不耗时
  AOP的方式实现监控
• 重视优先级设置
  Process.setThredPriority()
  可以设置多次

实战

• 第一种方式:Executors，会提示：手动创建线程池，效果会更好哦

public class ThreadPoolUtils {
    /**
     * 会提示：手动创建线程池，效果会更好哦
     */
    private static ExecutorService sService = Executors.newFixedThreadPool(5, new ThreadFactory() {
        @Override
        public Thread newThread(@NonNull Runnable runnable) {
            Thread thread = new Thread();
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            thread.setName("ThreadPoolUtils's ExecutorService");
            return thread;
        }
    });

    public static ExecutorService getService() {
        return sService;
    }
}

使用

     ThreadPoolUtils.getService().execute(new Runnable() {
            @Override
            public void run() {
                //提高优先级
                Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
                String oldName = Thread.currentThread().getName();
                //方便查看哪个线程报错
                Thread.currentThread().setName("MainActivity Thread Name");
                Thread.currentThread().setName(oldName);
            }
        });

• 第二种方式：手动创建线程池

    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 static final int KEEP_ALIVE_SECONDS = 30;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            return new Thread(r, "ThreadPoolUtils's ThreadFactory" + mCount.getAndIncrement());
        }
    };

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;


    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
    public static ThreadPoolExecutor getThreadPoolExecutor() {
        return THREAD_POOL_EXECUTOR;
    }

锁定线程创建者

锁定线程创建背景

• 项目变大之后收敛线程
• 项目源码，三方库，aar中都有线程的创建
• 避免恶化的一种监控预防手段

方案分析

• 创建线程的位置获取堆栈
• 所有的异步方式都会走到new Thread
• 比较适合hook手段
  找hook点：构造函数或者特定方法
  Thread的构造函数

优雅的方案:ARTHook

• 挂钩，将额外的代码钩住原有的方法，修改执行逻辑
• 框架：Epic(不能带到线上环境)

        DexposedBridge.hookAllConstructors(Thread.class, new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                super.afterHookedMethod(param);
                Thread thread = (Thread) param.thisObject;
                LogUtils.i(thread.getName() + " stack " + Log.getStackTraceString(new Throwable()));
            }
        });

线程收敛方案

• 直接依赖线程库
• 缺点：线程库更新可能会导致基础库更新
• 基础库内部暴露API：setExecutor
• 初始化的时候注入统一的线程库
• 代码。工具类里面添加代码(UIUtils)

    private static ExecutorService sExecutorService;

    public static void setExecutorService(ExecutorService executorService) {
        sExecutorService = executorService;
    }

    public static void exectur(Runnable runnable) {
        //如果外部库不为空，则使用外部，否则使用自己的
        if (sExecutorService != null) {
            sExecutorService.execute(runnable);
        } else {
            ThreadPoolUtils.getService().execute(runnable);
        }
    }

注意：1.要区分任务类型：IO还是CPU密集型,IO就是上面优化实战的第一种方式Executors,CPU就是第二种方式手动创建
2.IO密集型任务不消耗CPU，核心池可以很大
3.CPU密集型任务：核心池大小h和CPU核心数有关