多线程优化
线程使用
给线程起名字
目的是什么？
在出 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/liaowjcoder/AndroidPerfermance
本文是笔者学习之后的总结，方便日后查看学习，有任何不对的地方请指正。
记录于 2019年4月16号
网友评论