android多线程以及线程池使用

之前有关线程、多线程、线程池等概念经常接触，但是实际工作中用的却不是很多，刚好公司app对商品详情页有一个优化的任务，在参考了一些主流app的处理方式以后，发现他们的思路都是一样的：拆分接口，模块化加载。

在确定了思路以后，对安卓客户端的程序设计我是这么考虑的:
- 接口请求与activity视图加载并发进行
- 尽可能早地进行接口请求
- 接口请求完成以后进入一个等待的状态，等待视图加载完成再进行数据绑定
- 由于接口请求完成的先后顺序不可控，需要一个统一的请求队列进行管理，并且利用synchronized关键字处理好同步问题
- 使用HandlerThread作为分发消息的单独线程
- 使用WeakReference来防止内存泄漏

首先介绍一些使用到的工具

• CountDownLatch
  CountDownLatch是一个同步工具类,它允许一个或多个线程一直等待,直到其他线程的操作执行完后再执行。
• HandlerThread
  HandlerThread是一个子线程，它拥有自己的消息队列，利用它可以实现子线程与主线程之间的通信。
• ExecutorService
  ExecutorService线程池，系统提供了多种线程池实例，这里我用到的是newFixedThreadPool，这是一种定长线程数的线程池，这里我配置的线程数是手机CPU核心数+1。

部分代码流程

1.进入DetailActivity之前就开始请求接口（我们将详情页接口拆分成了6个接口）

//title和image分别为商品的标题和图片，我们可以在进入activity后先显示这2项，一般都可以在入口处获取到这2项数据，这样能给人一种快速打开页面的感觉，主流的app都是这么处理的
public static void start(Activity activity, PageExtras pageExtras) {
        if (pageExtras != null) {
            ItemDataQueue.get().loadAll(pageExtras.getItemUid(), new int[]{MSG_WHAT_BASIC,
                    MSG_WHAT_COMMENT,
                    MSG_WHAT_COUPON,
                    MSG_WHAT_MARKET,
                    MSG_WHAT_SKU,
                    MSG_WHAT_SUGGEST});
            Intent intent = new Intent(activity, DetailActivity.class);
            intent.putExtra("item_uid", pageExtras.getItemUid());
            intent.putExtra("title", pageExtras.getTitle());
            intent.putExtra("image", pageExtras.getImage());
            activity.startActivity(intent);
        }
    }
//请求队列
public class ItemDataQueue {
    private static ItemDataQueue itemDataQueue;

    public synchronized static ItemDataQueue get(){
        if (itemDataQueue == null){
            itemDataQueue = new ItemDataQueue();
        }
        return itemDataQueue;
    }
    private ItemDataQueueLatch<MKItemBasic> countDownLatchBasic;
    //省略其余5个
    /**
     * 并行加载所有请求
     * @param item_uid
     */
    public void loadAll(final String item_uid , int...targets){
        cancelAll();
        if (targets != null){
            for (int t : targets){
                switch (t){
                    case DetailActivity.MSG_WHAT_BASIC:
                        countDownLatchBasic = new ItemDataQueueLatch<>(item_uid);
                        httpBasic(item_uid);
                        break;
                    ...
                }
            }

        }
    }
    private void httpBasic(final String item_uid) {
        countDownLatchBasic = new ItemDataQueueLatch<>(item_uid);
        MKItemCenter.getItemBasic( item_uid, new BusinessListener(null) {
            @Override
            public void onSuccess(MKBaseObject baseObject) {
                if (countDownLatchBasic != null && TextUtils.equals(countDownLatchBasic.getItem_uid(),item_uid)){
                    countDownLatchBasic.setData(((MKItemBasicResponse)baseObject).getData());
                    countDownLatchBasic.countDown();
                }
            }

            @Override
            public void onFail(MKBaseObject baseObject) {
                if (countDownLatchBasic != null && TextUtils.equals(countDownLatchBasic.getItem_uid(),item_uid)){
                    countDownLatchBasic.countDown();
                }
            }

            @Override
            public void onError() {
                if (countDownLatchBasic != null && TextUtils.equals(countDownLatchBasic.getItem_uid(),item_uid)){
                    countDownLatchBasic.countDown();
                }
            }
        });
    }
    public MKItemBasic getBasic(String item_uid){
        if (countDownLatchBasic == null){
            return null;
        }
        try {
            countDownLatchBasic.await(TIME_OUT_SEC, TimeUnit.SECONDS);
            if (countDownLatchBasic != null && TextUtils.equals(countDownLatchBasic.getItem_uid(),item_uid)){
                return countDownLatchBasic.getData();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
    public void cancelAll(){
        if (countDownLatchBasic != null){
            countDownLatchBasic.countDown();
            countDownLatchBasic = null;
        }
        ...
    }
}

2.视图初始化完以后开始接收数据

//创建线程池
public class ItemDataThreadPool {

    private static ExecutorService executorService;

    //分发消息的队列的单独线程
    private static HandlerThread handlerThread;

    public static ExecutorService get(){
        if (executorService == null){
            executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);
        }
        return executorService;
    }

    public static HandlerThread getHandlerThread(){
        if (handlerThread == null || !handlerThread.isAlive()){
            handlerThread = new HandlerThread("DetailActivity");
            handlerThread.start();
        }
        return handlerThread;
    }

}
//DetailActivity
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);
        ...
        fetchData(mItemUid,targets);
    }
    public void fetchData(String item_uid, int... targets) {
        for (int t : targets) {
            switch (t) {
                case DetailActivity.MSG_WHAT_BASIC:
                    mData.clearBasic();
                    ItemDataThreadPool.get().execute(new Runnable() {
                        @Override
                        public void run() {
                            Message msg = new Message();
                            msg.what = MSG_WHAT_BASIC;
                            msg.obj = ItemDataQueue.get().getBasic(mItemUid);
                            mHandler.sendMessage(msg);
                        }
                    });
                    break;
                ...
            }
        }
    }
//向主线程发送接收到的数据
public class ItemHandler extends Handler {

    private final WeakReference<DetailActivity> mActivity;

    public ItemHandler(Looper looper , DetailActivity activity){
        super(looper);
        mActivity = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        if (mActivity.get() != null && !mActivity.get().isFinishing()){
            switch (msg.what){
                case MSG_WHAT_BASIC:
                    if (msg.obj != null){
                        mActivity.get().setBasicData((MKItemBasic) msg.obj);
                    } else {
                        mActivity.get().setBasicData(null);
                    }
                    break;
                ...
            }
        }
    }
}
//最后在DetailActivity的setBasicData等方法中绑定数据
public void setBasicData(final MKItemBasic basicData) {
...
}

总结：
大致的流程就是这样，具体的代码逻辑就不贴了。在视图上，我采用模块化加载的方式将页面分成了多个模块，最理想的是每个接口对应相应的模块，但是实际上模块与接口之间都是穿插的较多，这时候就要用到synchronized实现同步了。