多线程优化

线程使用

给线程起名字

目的是什么？

在出 bug 时方便定位到是哪个线程出问题。

在 Android SDk 提供的类中，也是有给线程起名字的。

• IntentService

//IntentService.java
@Override
public void onCreate() {
    super.onCreate();
    //指定线程名字
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}
//HandlerThread.java
public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
}

• AsyncTask

//AsyncTask.java
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);
    public Thread newThread(Runnable r) {
        //指定线程名字
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};

• RxJava#IoSchedule 构造函数，可以传入一个线程工厂，通过线程工厂在创建线程时可以设置对应的线程的名字。

public IoScheduler(ThreadFactory threadFactory) {
    this.threadFactory = threadFactory;
    this.pool = new AtomicReference<CachedWorkerPool>(NONE);
    start();
}

Observable.create(new ObservableOnSubscribe<Object>() {
    @Override
    public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
    }
}).subscribeOn(RxJavaPlugins.createIoScheduler(new ThreadFactory() {
    @Override
    public Thread newThread(Runnable runnable) {
        Thread thread = new Thread(runnable);
        thread.setName("我是线程名字哦");
        return thread;
    }
}));

从上面示例可以看出， SDk 或者其他开源库提供的源码都给线程起名字了，难道我们自己开启的线程还能不写吗？

什么时候设置？

参考上面给出的栗子，在创建线程的时候指定线程的名字

还有一种方式是，在运行时，给当前线程设置名字。

ThreadPoolManager 是笔者封装的 CPU 密集型和 IO 密集型的线程池封装类。

ThreadPoolManager.getCpuExecutor().execute(new Runnable() {
    @Override
    public void run() {
        //线程体中动态设置名字
        String oldName = Thread.currentThread().getName();
        Thread.currentThread().setName("initBugly");
        //初始化 bugly，这里假设 bugly 是 cpu 密集型的任务。所以这里选择 cpu 密集型的线程池
        initBugly();
        //执行完毕之后，设置回以前的名字，方便下次线程复用
        Thread.currentThread().setName(oldName);
    }
});

检测关键异步任务的耗时情况

在 Android 开发中，耗时任务是不应该在主线程中执行的，所以一般会将任务放在异步线程中去自行，但是任务在异步线程跑，不代表它不耗时。

举一个栗子:我们的项目是做直播类型的，当主播开播时，我们需要给后台定时去上报当前的开播情况，如果后台检测到客户端没有上报，那么就认为当前主播掉线了，应该将其下线。所以说这个上报的任务是比较关键的，因此我们要关注这个任务的耗时情况。

实际上，需要检测的就是线程执行的 run() 方法的耗时时间：

• 我们的上报任务ReportTask：

public class ReportTask implements Runnable {
    private static final String TAG = ReportTask.class.getSimpleName();

    @Override
    public void run() {
        try {
            Log.d(TAG, "report task running");
            //模拟上报需要的耗时
            Thread.sleep(3000);
            Log.d(TAG, "report task end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 开启线程执行这个任务ReportTask

这里只是演示使用，就没有使用线程池，而是直接 new Thread 的方式，实际开发建议不要这样去做。

private void report() {
    new Thread(new ReportTask()).start();
}

上面的 ReportTask 就是开播时的定时上报任务，现在要做的就是在 run 方法体中计算耗时。

方式一：在 run 方法中打点计时

public void run() {
   long startTime = System.currentTimeMillis();
   //业务计算操作
   long end = System.currentTimeMillis();
   Log.d(TAG, "ReportTask run :" + (end - start));
}

上面这种方式侵入性比较大，下面来看另一种比较优雅的方式：

方式二：使用 hook 技术

在介绍第二种方式之前，这里推荐一个开源库： epic，笔者是依赖这个库来 hook 上报任务 ReportTask 的。这个库具体如何使用，可以进入官网查看哦。

下面我对这个库做了简单地封装(DexposedManager源码下面会提供)，使用 DexposedManager 来实现 hook 机制。

//使用 hook 机制检测某一个方法的耗时
DexposedManager.getIntance(this).hookMethod(ReportTask.class, "run", new DexposedManager.HookMethodCallback<ReportTask>() {
    private long start = 0;
    // run方法开始执行前
    @Override
    public void hookMethodBefore(ReportTask reportTask) {
        start = System.currentTimeMillis();
    }
    // run方法开始执行后
    @Override
    public void hookMothodAfter(ReportTask reportTask) {
        long end = System.currentTimeMillis();
        Log.d(TAG, "ReportTask run :" + (end - start));
    }
    @Override
    public void hookConstruct(ReportTask reportTask) {
    }
});

执行结果：

04-16 11:20:50.670 4192-4228/com.example.androidperfermance D/ReportTask: report task running
04-16 11:20:53.670 4192-4228/com.example.androidperfermance D/ReportTask: report task end
04-16 11:20:53.670 4192-4228/com.example.androidperfermance D/PerformanceApp: ReportTask run :3000

相信上面的代码都不难看懂，在 hookMethod 中的参数如下：

• ReportTask.class 表示你要 hook 的那个方法的对应的那个类字节码，我们要 hook 的是 ReportTask 中的 run 方法，因此传入的是 ReportTask.class。
• "run":表示需要 hook 的方法名字，我估计内部是使用反射区实现的。
• DexposedManager.HookMethodCallback ，这个回调是定义在 DexposedManager 类中的，作用就是 hook 到方法时回到给应用层，然后做一些业务处理，例如这里我们就用来检测方法之前前后的耗时情况。

避免直接创建Thread

直接创建Thread的弊端

Thread thread = new Thread(task);
thread.start();

直接创建线程的弊端如下，这也是为什么开发过程中要用线程池的原因：

• 不易于管理，例如定时执行某一个任务等操作。
• 不能复用，也就是说 run 方法执行完毕之后，线程就结束了。
• 线程的频繁创建和销毁是比较消耗资源的。

锁定线程的创建者

上面说明了直接创建线程的弊端，对于一个庞大的项目来说，一个一个的去检测 new Thread() 这种代码是不可取的，笔者这里需要采取上面 hook 上报任务 ReportTask 的方式来锁定线程的创建者。

找 hook 点：线程构造函数被调用地方就是 hook 点

具体代码如下：

DexposedManager.getIntance(this).hookConstructs(Thread.class, new DexposedManager.HookConstructorCallback<Thread>() {
    @Override
    public void hookConstruct(Thread thread) {
        //得到创建线程的堆栈信息
        Log.i(TAG, thread.getName() + " stack " + Log.getStackTraceString(new Throwable()));
    }
});

执行结果如下：

hook 线程创建

设置线程优先级

线程优先级会影响获取 CPU 的概率，具体的跟 nice value 和 cgroup 有关。

Thread thread = new Thread(){
    public void run() {
        //设置线程优先级
        Process.setPriority(Process.THREAD_PRIORITY_BACKGROUND);
    }
};

下面来关注一下哪些异步框架如何设置这些 nice value 。

• HanlderThread

HandlerThread 默认优先级

• AsyncTask

AsyncTask默认优先级

参考

• https://github.com/tiann/epic/

项目地址

https://github.com/liaowjcoder/AndroidPerfermance

本文是笔者学习之后的总结，方便日后查看学习，有任何不对的地方请指正。

记录于 2019年4月16号