Android线程池（二）

本篇主要介绍Android自带的线程池的管理。

包含开始任务、重新加载、添加删除任务等，示例代码如下：

package com.jiao.threadpooltest;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ProgressBar;
import android.widget.Toast;

/**
 * @TODO [线程池控制 ]
 */
public class MyRunnableActivity extends Activity implements OnClickListener {

    /** 任务执行队列 */
    private ConcurrentLinkedQueue<MyRunnable> taskQueue = null;
    /**
     * 正在等待执行或已经完成的任务队列
     * 
     * 备注：Future类，一个用于存储异步任务执行的结果，比如：判断是否取消、是否可以取消、
     * 是否正在执行、是否已经完成等
     * 
     * */
    private ConcurrentMap<Future, MyRunnable> taskMap = null;

    /**
     * 创建一个不限制大小的线程池 此类主要有以下好处 1，以共享的无界队列方式来运行这些线程. 
     * 2，执行效率高。 3，在任意点，在大多数nThreads 线程会处于处理任务的活动状态
     * 4，如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。
     * 
     * */
    private ExecutorService mES = null;
    /**
     * 在此类中使用同步锁时使用如下lock对象即可，官方推荐的，不推荐直接使用MyRunnableActivity.this类型的,可以详细读一下/
     * framework/app下面的随便一个项目
     */
    private Object lock = new Object();

    /** 唤醒标志，是否唤醒线程池工作 */
    private boolean isNotify = true;

    /** 线程池是否处于运行状态(即:是否被释放!) */
    private boolean isRuning = true;

    /** 任务进度 */
    private ProgressBar pb = null;

    /** 用此Handler来更新我们的UI */
    private Handler mHandler = null;
    /**
     * Overriding methods
     * 
     * @param savedInstanceState
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.my_runnable_main);
        init();
    }

    public void init() {
        pb = (ProgressBar) findViewById(R.id.progressBar1);
        findViewById(R.id.button1).setOnClickListener(this);
        findViewById(R.id.button2).setOnClickListener(this);
        findViewById(R.id.button3).setOnClickListener(this);
        findViewById(R.id.button4).setOnClickListener(this);
        findViewById(R.id.button5).setOnClickListener(this);
        taskQueue = new ConcurrentLinkedQueue<MyRunnable>();
        taskMap = new ConcurrentHashMap<Future, MyRunnable>();
        if (mES == null) {
            // 创建一个线程池
            mES = Executors.newCachedThreadPool();
        }

        // 用于更新ProgressBar进度条
        mHandler = new Handler() {
            /**
             * Overriding methods
             * 
             * @param msg
             */
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                pb.setProgress(msg.what);
            }

        };

    }

    /**
     * Overriding methods
     * 
     * @param v
     */
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.button1:// 开始任务
            start();
            break;
        case R.id.button2:// 取消任务
            stop();
            break;
        case R.id.button3:// 重新加载
            reload(new MyRunnable(mHandler));
            break;
        case R.id.button4:// 释放资源
            release();
            break;
        case R.id.button5:// 添加任务
            addTask(new MyRunnable(mHandler));
            break;

        default:
            break;
        }
    }

    /**
     * <Summary Description>
     */
    private void addTask(final MyRunnable mr) {

        mHandler.sendEmptyMessage(0);

        if (mES == null) {
            mES = Executors.newCachedThreadPool();
            notifyWork();
        }

        if (taskQueue == null) {
            taskQueue = new ConcurrentLinkedQueue<MyRunnable>();
        }

        if (taskMap == null) {
            taskMap = new ConcurrentHashMap<Future, MyRunnable>();
        }

        mES.execute(new Runnable() {

            @Override
            public void run() {
                /**
                 * 插入一个Runnable到任务队列中
                 * 这个地方解释一下,offer跟add方法,试了下,效果都一样,没区别,官方的解释如下: 1 offer : Inserts
                 * the specified element at the tail of this queue. As the queue
                 * is unbounded, this method will never return {@code false}. 2
                 * add: Inserts the specified element at the tail of this queue.
                 * As the queue is unbounded, this method will never throw
                 * {@link IllegalStateException} or return {@code false}.
                 * 
                 * 
                 * */
                taskQueue.offer(mr);
                // taskQueue.add(mr);
                notifyWork();
            }
        });

        Toast.makeText(MyRunnableActivity.this, "已添加一个新任务到线程池中 ！", 0).show();
    }

    /**
     * <Summary Description>
     */
    private void release() {
        Toast.makeText(MyRunnableActivity.this, "释放所有占用的资源！", 0).show();

        /** 将ProgressBar进度置为0 */
        mHandler.sendEmptyMessage(0);
        isRuning = false;

        Iterator iter = taskMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry<Future, MyRunnable> entry = (Map.Entry<Future, MyRunnable>) iter
                    .next();
            Future result = entry.getKey();
            if (result == null) {
                continue;
            }
            result.cancel(true);
            taskMap.remove(result);
        }
        if (null != mES) {
            mES.shutdown();
        }

        mES = null;
        taskMap = null;
        taskQueue = null;

    }

    /**
     * 重新加载
     */
    private void reload(final MyRunnable mr) {
        mHandler.sendEmptyMessage(0);//重置进度条
        if (mES == null) {
            mES = Executors.newCachedThreadPool();
            notifyWork();
        }

        if (taskQueue == null) {
            taskQueue = new ConcurrentLinkedQueue<MyRunnable>();
        }

        if (taskMap == null) {
            taskMap = new ConcurrentHashMap<Future, MyRunnable>();
        }

        mES.execute(new Runnable() {

            @Override
            public void run() {
                /** 插入一个Runnable到任务队列中 */
                taskQueue.offer(mr);
                // taskQueue.add(mr);
                notifyWork();
            }
        });

        mES.execute(new Runnable() {
            @Override
            public void run() {
                if (isRuning) {
                    MyRunnable myRunnable = null;
                    synchronized (lock) {
                        myRunnable = taskQueue.poll(); // 从线程队列中取出一个Runnable对象来执行，如果此队列为空，则调用poll()方法会返回null
                        if (myRunnable == null) {
                            isNotify = true;
                        }
                    }

                    if (myRunnable != null) {
                        taskMap.put(mES.submit(myRunnable), myRunnable);
                    }
                }
            }
        });
    }

    /**
     * <Summary Description>
     */
    private void stop() {

        Toast.makeText(MyRunnableActivity.this, "任务已被取消！", 0).show();

        for (MyRunnable runnable : taskMap.values()) {
            runnable.setCancleTaskUnit(true);
        }
    }

    /**
     * <Summary Description>
     */
    private void start() {

        if (mES == null || taskQueue == null || taskMap == null) {
            Log.i("KKK", "某资源是不是已经被释放了？");
            return;
        }
        mES.execute(new Runnable() {
            @Override
            public void run() {
                if (isRuning) {
                    MyRunnable myRunnable = null;
                    synchronized (lock) {
                        myRunnable = taskQueue.poll(); // 从线程队列中取出一个Runnable对象来执行，如果此队列为空，则调用poll()方法会返回null
                        if (myRunnable == null) {
                            isNotify = true;
                            // try
                            // {
                            // myRunnable.wait(500);
                            // }
                            // catch (InterruptedException e)
                            // {
                            // e.printStackTrace();
                            // }
                        }
                    }

                    if (myRunnable != null) {
                        taskMap.put(mES.submit(myRunnable), myRunnable);
                    }
                }

            }
        });
    }

    private void notifyWork() {
        synchronized (lock) {
            if (isNotify) {
                lock.notifyAll();
                isNotify = !isNotify;
            }
        }
    }
}