「性能优化3.1」Android多线程优化

多线程优化

线程使用

给线程起名字

目的是什么?

在出 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号

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值