Android线程池使用

一:无大小限制的线程池执行效果如下


1.gif

二:限制按顺序来执行任务的线程池效果如下


2.gif

三:一个一个任务的执行线程池效果如下(与按顺序执行效果是一样的,只是内部实现稍有不同)
3.gif

四:按指定个数来执行任务的线程池效果如下


4.gif

五:创建一个可在指定时间里执行任务的线程池,亦可重复执行,不常用,效果与四相同
5.gif

六:按指定工厂模式来执行的线程池,效果与四、五一样,但用方式六创建的线程池都有在工厂中指定的线程属性,
比如:线程名字、是否为用户线程等等属性
6.gif

七:线程池中任务执行时可暂停效果图如下
7.gif

八:用Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的效果图如下


8.gif

哦的了,效果看完了,现在就请大家自行修改AndroidManifest.xml中主Activity的入口来看两种不同方式实现的代码效果吧,首先,先贴一下Main.java类的代码,希望大家详细看里面的注释,一定要详细看,你不会吃亏的,相信我!

方式一(纯ExecutorService、AsyncTask、Runnable关联实现相关文件如下):

1.1:主类文件(Main.java)

/* 
 * FileName:  Main.java 
 * CopyRight:  Belong to  <XiaoMaGuo Technologies > own  
 * Description:  <description> 
 * Modify By :  XiaoMaGuo ^_^  
 * Modify Date:   2013-10-15 
 * Follow Order No.:  <Follow Order No.> 
 * Modify Order No.:  <Modify Order No.> 
 * Modify Content:  <modify content > 
 */  
package com.xiaoma.threadpooltest;  
   
import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ThreadFactory;  
   
import android.annotation.TargetApi;  
import android.app.Activity;  
import android.content.Context;  
import android.os.AsyncTask;  
import android.os.Build;  
import android.os.Bundle;  
import android.os.SystemClock;  
import android.util.AttributeSet;  
import android.util.Log;  
import android.view.LayoutInflater;  
import android.view.View;  
import android.view.ViewGroup;  
import android.widget.AdapterView;  
import android.widget.AdapterView.OnItemClickListener;  
import android.widget.BaseAdapter;  
import android.widget.LinearLayout;  
import android.widget.ListView;  
import android.widget.ProgressBar;  
import android.widget.TextView;  
import android.widget.Toast;  
   
/** 
 * @TODO [The Class File Description] 
 * @author XiaoMaGuo ^_^ 
 * @version [version-code, 2013-10-15] 
 * @since [Product/module] 
 */  
@TargetApi(Build.VERSION_CODES.HONEYCOMB)  
public class Main extends Activity  
{  
    private static int order = 0;  
   
    /** 总共多少任务(根据CPU个数决定创建活动线程的个数,这样取的好处就是可以让手机承受得住) */  
    // private static final int count = Runtime.getRuntime().availableProcessors() * 3 + 2;  
   
    /** 总共多少任务(我是在模拟器里面跑的,为了效果明显,所以写死了为10个,如果在手机上的话,推荐使用上面的那个count) */  
    private static final int count = 10;  
   
    /** 每次只执行一个任务的线程池 */  
    private static ExecutorService singleTaskExecutor = null;  
   
    /** 每次执行限定个数个任务的线程池 */  
    private static ExecutorService limitedTaskExecutor = null;  
   
    /** 所有任务都一次性开始的线程池 */  
    private static ExecutorService allTaskExecutor = null;  
   
    /** 创建一个可在指定时间里执行任务的线程池,亦可重复执行 */  
    private static ExecutorService scheduledTaskExecutor = null;  
   
    /** 创建一个可在指定时间里执行任务的线程池,亦可重复执行(不同之处:使用工程模式) */  
    private static ExecutorService scheduledTaskFactoryExecutor = null;  
   
    private List<AsyncTaskTest> mTaskList = null;  
   
    /** 任务是否被取消 */  
    private boolean isCancled = false;  
   
    /** 是否点击并取消任务标示符 */  
    private boolean isClick = false;  
   
    /** 线程工厂初始化方式一 */  
    ThreadFactory tf = Executors.defaultThreadFactory();  
   
    /** 线程工厂初始化方式二 */  
    private static class ThreadFactoryTest implements ThreadFactory  
    {  
   
        @Override  
        public Thread newThread(Runnable r)  
        {  
            Thread thread = new Thread(r);  
            thread.setName("XiaoMaGuo_ThreadFactory");  
            thread.setDaemon(true); // 将用户线程变成守护线程,默认false  
            return thread;  
        }  
    }  
   
    static  
    {  
        singleTaskExecutor = Executors.newSingleThreadExecutor();// 每次只执行一个线程任务的线程池  
        limitedTaskExecutor = Executors.newFixedThreadPool(3);// 限制线程池大小为7的线程池  
        allTaskExecutor = Executors.newCachedThreadPool(); // 一个没有限制最大线程数的线程池  
        scheduledTaskExecutor = Executors.newScheduledThreadPool(3);// 一个可以按指定时间可周期性的执行的线程池  
        scheduledTaskFactoryExecutor = Executors.newFixedThreadPool(3, new ThreadFactoryTest());// 按指定工厂模式来执行的线程池  
        scheduledTaskFactoryExecutor.submit(new Runnable()  
        {  
   
            @Override  
            public void run()  
            {  
                Log.i("KKK", "This is the ThreadFactory Test  submit Run! ! ! ");  
            }  
        });  
    };  
   
    @Override  
    public void onCreate(Bundle icicle)  
    {  
        super.onCreate(icicle);  
        setContentView(R.layout.demo);  
        final ListView taskList = (ListView)findViewById(R.id.task_list);  
        taskList.setAdapter(new AsyncTaskAdapter(getApplication(), count));  
        taskList.setOnItemClickListener(new OnItemClickListener()  
        {  
   
            @Override  
            public void onItemClick(AdapterView<?> parent, View view, int position, long id)  
            {  
                if (position == 0) // 以第一项为例,来测试关闭线程池  
                {  
                    /** 
                     * 会关闭线程池方式一:但不接收新的Task,关闭后,正在等待 执行的任务不受任何影响,会正常执行,无返回值! 
                     */  
                    // allTaskExecutor.shutdown();  
   
                    /** 
                     * 会关闭线程池方式二:也不接收新的Task,并停止正等待执行的Task(也就是说, 执行到一半的任务将正常执行下去),最终还会给你返回一个正在等待执行但线程池关闭却没有被执行的Task集合! 
                     */  
                    List<Runnable> unExecRunn = allTaskExecutor.shutdownNow();  
   
                    for (Runnable r : unExecRunn)  
                    {  
                        Log.i("KKK", "未执行的任务信息:=" + unExecRunn.toString());  
                    }  
                    Log.i("KKK", "Is shutdown ? = " + String.valueOf(allTaskExecutor.isShutdown()));  
                    allTaskExecutor = null;  
                }  
   
                // 以第二项为例来测试是否取消执行的任务  
                AsyncTaskTest sat = mTaskList.get(1);  
                if (position == 1)  
                {  
                    if (!isClick)  
                    {  
                        sat.cancel(true);  
                        isCancled = true;  
                        isClick = !isClick;  
                    }  
                    else  
                    {  
                        sat.cancel(false);  
                        isCancled = false;  
                        // isClick = false;  
                        isClick = !isClick;  
                        if (null != sat && sat.getStatus() == AsyncTask.Status.RUNNING)  
                        {  
                            if (sat.isCancelled())  
                            {  
                                sat = new AsyncTaskTest(sat.mTaskItem);  
                            }  
                            else  
                            {  
                                Toast.makeText(Main.this, "A task is already running, try later", Toast.LENGTH_SHORT)  
                                    .show();  
                            }  
                        }  
   
                        /** 
                         * 由于上面测试关闭,在不重新生成allTaskExecutor的同时,会报异常(没有可以使用的线程池,故此处重新生成线程池对象) 
                         */  
                        if (allTaskExecutor == null)  
                        {  
                            allTaskExecutor = Executors.newCachedThreadPool();  
                        }  
                        sat.executeOnExecutor(allTaskExecutor); // The task is already running(这也是个异常哦,小心使用! )  
                    }  
                }  
                else  
                {  
                    sat.cancel(false);  
                    isCancled = false;  
                    // sat.execute(sat.mTaskItem);  
                    // sat.executeOnExecutor(allTaskExecutor);  
                }  
   
            }  
        });  
    }  
   
    /** 
     * @TODO [ListView Item的条目适配器] 
     * @author XiaoMaGuo ^_^ 
     * @version [version-code, 2013-10-22] 
     * @since [Product/module] 
     */  
    private class AsyncTaskAdapter extends BaseAdapter  
    {  
        private Context mContext;  
   
        private LayoutInflater mFactory;  
   
        private int mTaskCount;  
   
        public AsyncTaskAdapter(Context context, int taskCount)  
        {  
            mContext = context;  
            mFactory = LayoutInflater.from(mContext);  
            mTaskCount = taskCount;  
            mTaskList = new ArrayList<AsyncTaskTest>(taskCount);  
        }  
   
        @Override  
        public int getCount()  
        {  
            return mTaskCount;  
        }  
   
        @Override  
        public Object getItem(int position)  
        {  
            return mTaskList.get(position);  
        }  
   
        @Override  
        public long getItemId(int position)  
        {  
            return position;  
        }  
   
        @Override  
        public View getView(int position, View convertView, ViewGroup parent)  
        {  
            if (convertView == null)  
            {  
                convertView = mFactory.inflate(R.layout.list_view_item, null);  
                AsyncTaskTest task = new AsyncTaskTest((MyListItem)convertView);  
   
                /** 
                 * 下面两种任务执行效果都一样,形变质不变 
                 * */  
                // task.execute();  
                // task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);  
   
                /** 
                 * 下面的方式在小于API 11级时效果是一样的,但在高版本中的稍微有点不同,可以看以下AsyncTask核心变量的定义就知道了使用如下 
                 * 方式时,系统会默认的采用五个一组,五个一组的方式来执行我们的任务,定义在:AsyncTask.class中,private static final int CORE_POOL_SIZE = 5; 
                 * */  
                // use AsyncTask#THREAD_POOL_EXECUTOR is the same to older version #execute() (less than API 11)  
                // but different from newer version of #execute()  
                // task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);  
   
                /** 
                 * 一个一个执行我们的任务,效果与按顺序执行是一样的(AsyncTask.SERIAL_EXECUTOR) 
                 * */  
                // task.executeOnExecutor(singleTaskExecutor);  
   
                /** 
                 * 按我们指定的个数来执行任务的线程池 
                 * */  
                // task.executeOnExecutor(limitedTaskExecutor);  
   
                /** 
                 * 不限定指定个数的线程池,也就是说:你往里面放了几个任务,他全部同一时间开始执行, 不管你手机受得了受不了 
                 * */  
                task.executeOnExecutor(allTaskExecutor);  
   
                /** 
                 * 创建一个可在指定时间里执行任务的线程池,亦可重复执行 
                 * */  
                // task.executeOnExecutor(scheduledTaskExecutor);  
   
                /** 
                 * 创建一个按指定工厂模式来执行任务的线程池,可能比较正规,但也不常用 
                 */  
                // task.executeOnExecutor(scheduledTaskFactoryExecutor);  
                mTaskList.add(task);  
            }  
            return convertView;  
        }  
    }  
   
    class AsyncTaskTest extends AsyncTask<Void, Integer, Void>  
    {  
        private MyListItem mTaskItem;  
   
        private String id;  
   
        private AsyncTaskTest(MyListItem item)  
        {  
            mTaskItem = item;  
            if (order < count || order == count)  
            {  
                id = "执行:" + String.valueOf(++order);  
            }  
            else  
            {  
                order = 0;  
                id = "执行:" + String.valueOf(++order);  
            }  
        }  
   
        @Override  
        protected void onPreExecute()  
        {  
            mTaskItem.setTitle(id);  
        }  
   
        /** 
         * Overriding methods 
         */  
        @Override  
        protected void onCancelled()  
        {  
            super.onCancelled();  
        }  
   
        @Override  
        protected Void doInBackground(Void... params)  
        {  
            if (!isCancelled() && isCancled == false) // 这个地方很关键,如果不设置标志位的话,直接setCancel(true)是无效的  
            {  
                int prog = 0;  
   
                /** 
                 * 下面的while中,小马写了个分支用来做个假象(任务东西刚开始下载的时候,速度快,快下载完成的时候就突然间慢了下来的效果, 大家可以想象一下,类似 
                 * :PP手机助手、91手机助手中或其它手机应用中,几乎都有这个假象,开始快,结束时就下载变慢了,讲白了 就是开发的人不想让你在下载到大于一半的时候,也就是快下载完的时候去点取消,你那样得多浪费 
                 * !所以造个假象,让你不想去取消而已) 
                 */  
                while (prog < 101)  
                {  
   
                    if ((prog > 0 || prog == 0) && prog < 70) // 小于70%时,加快进度条更新  
                    {  
                        SystemClock.sleep(100);  
                    }  
                    else  
                    // 大于70%时,减慢进度条更新  
                    {  
                        SystemClock.sleep(300);  
                    }  
   
                    publishProgress(prog); // 更新进度条  
                    prog++;  
                }  
            }  
            return null;  
        }  
   
        @Override  
        protected void onPostExecute(Void result)  
        {  
        }  
   
        @Override  
        protected void onProgressUpdate(Integer... values)  
        {  
            mTaskItem.setProgress(values[0]); // 设置进度  
        }  
    }  
}  
   
/** 
 * @TODO [一个简单的自定义 ListView Item] 
 * @author XiaoMaGuo ^_^ 
 * @version [version-code, 2013-10-22] 
 * @since [Product/module] 
 */  
class MyListItem extends LinearLayout  
{  
    private TextView mTitle;  
   
    private ProgressBar mProgress;  
   
    public MyListItem(Context context, AttributeSet attrs)  
    {  
        super(context, attrs);  
    }  
   
    public MyListItem(Context context)  
    {  
        super(context);  
    }  
   
    public void setTitle(String title)  
    {  
        if (mTitle == null)  
        {  
            mTitle = (TextView)findViewById(R.id.task_name);  
        }  
        mTitle.setText(title);  
    }  
   
    public void setProgress(int prog)  
    {  
        if (mProgress == null)  
        {  
            mProgress = (ProgressBar)findViewById(R.id.task_progress);  
        }  
        mProgress.setProgress(prog);  
    }  
}

1.2:布局文件

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:paddingLeft="10dip"  
    android:paddingRight="10dip"  
    android:orientation="vertical" >  
    <ListView android:id="@+id/task_list"  
        android:layout_width="fill_parent"  
        android:layout_height="wrap_content"  
        android:divider="#cccccc"  
        android:dividerHeight="0.6dip"  
        android:footerDividersEnabled="true"  
        android:headerDividersEnabled="true" />  
</LinearLayout>

方式二(Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的相关文件如 下):
2.1:主类文件(MyRunnableActivity.java)

/* 
 * FileName:  MyRunnableActivity.java 
 * CopyRight:  Belong to  <XiaoMaGuo Technologies > own  
 * Description:  <description> 
 * Modify By :  XiaoMaGuo ^_^  
 * Modify Date:   2013-10-21 
 * Follow Order No.:  <Follow Order No.> 
 * Modify Order No.:  <Modify Order No.> 
 * Modify Content:  <modify content > 
 */  
package com.xiaoma.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 [线程池控制 ] 
 * @author XiaoMaGuo ^_^ 
 * @version [version-code, 2013-10-22] 
 * @since [Product/module] 
 */  
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)  
    {  
        // TODO Auto-generated method stub  
        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;  
   
    }  
   
    /** 
     * <Summary Description> 
     */  
    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;  
            }  
        }  
    }  
}

2.2:辅助类(MyRunnable.java)

/* 
 * FileName:  MyRunnable.java 
 * CopyRight:  Belong to  <XiaoMaGuo Technologies > own  
 * Description:  <description> 
 * Modify By :  XiaoMaGuo ^_^  
 * Modify Date:   2013-10-21 
 * Follow Order No.:  <Follow Order No.> 
 * Modify Order No.:  <Modify Order No.> 
 * Modify Content:  <modify content > 
 */  
package com.xiaoma.threadpooltest;  
   
import android.os.Handler;  
import android.os.SystemClock;  
import android.util.Log;  
   
/** 
 * @TODO [The Class File Description] 
 * @author XiaoMaGuo ^_^ 
 * @version [version-code, 2013-10-21] 
 * @since [Product/module] 
 */  
public class MyRunnable implements Runnable  
{  
   
    private boolean cancleTask = false;  
   
    private boolean cancleException = false;  
   
    private Handler mHandler = null;  
   
    public MyRunnable(Handler handler)  
    {  
        mHandler = handler;  
    }  
   
    /** 
     * Overriding methods 
     */  
    @Override  
    public void run()  
    {  
        Log.i("KKK", "MyRunnable  run() is executed!!! ");  
        runBefore();  
        if (cancleTask == false)  
        {  
            running();  
            Log.i("KKK", "调用MyRunnable run()方法");  
        }  
   
        runAfter();  
    }  
   
    /** 
     * <Summary Description> 
     */  
    private void runAfter()  
    {  
        Log.i("KKK", "runAfter()");  
    }  
   
    /** 
     * <Summary Description> 
     */  
    private void running()  
    {  
        Log.i("KKK", "running()");  
        try  
        {  
            // 做点有可能会出异常的事情!!!  
            int prog = 0;  
            if (cancleTask == false && cancleException == false)  
            {  
                while (prog < 101)  
                {  
                    if ((prog > 0 || prog == 0) && prog < 70)  
                    {  
                        SystemClock.sleep(100);  
                    }  
                    else  
                    {  
                        SystemClock.sleep(300);  
                    }  
                    if (cancleTask == false)  
                    {  
                        mHandler.sendEmptyMessage(prog++);  
                        Log.i("KKK", "调用 prog++ = " + (prog));  
                    }  
                }  
            }  
        }  
        catch (Exception e)  
        {  
            cancleException = true;  
        }  
    }  
   
    /** 
     * <Summary Description> 
     */  
    private void runBefore()  
    {  
        // TODO Auto-generated method stub  
        Log.i("KKK", "runBefore()");  
    }  
   
    public void setCancleTaskUnit(boolean cancleTask)  
    {  
        this.cancleTask = cancleTask;  
        Log.i("KKK", "点击了取消任务按钮 !!!");  
        // mHandler.sendEmptyMessage(0);  
    }  
   
}

2.3:布局文件

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical" >  
   
    <LinearLayout  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:orientation="horizontal" >  
   
        <Button  
            android:id="@+id/button5"  
            android:layout_width="0dp"  
            android:layout_height="wrap_content"  
            android:layout_weight="1"  
            android:text="添加任务" />  
   
        <Button  
            android:id="@+id/button1"  
            android:layout_width="0dp"  
            android:layout_height="wrap_content"  
            android:layout_weight="1"  
            android:text="开始任务" />  
   
        <Button  
            android:id="@+id/button2"  
            android:layout_width="0dp"  
            android:layout_height="wrap_content"  
            android:layout_weight="1"  
            android:text="取消任务" />  
   
        <Button  
            android:id="@+id/button3"  
            android:layout_width="0dp"  
            android:layout_height="wrap_content"  
            android:layout_weight="1"  
            android:text="重新加载" />  
   
        <Button  
            android:id="@+id/button4"  
            android:layout_width="0dp"  
            android:layout_height="wrap_content"  
            android:layout_weight="1"  
            android:text="释放资源" />  
    </LinearLayout>  
   
    <include layout="@layout/my_runnable_merge"/>  
   
</LinearLayout>

方式一、方式二的全局配置文件AndroidManifest.xml文件的配置如下:

<?xml version="1.0" encoding="utf-8"?>  
<manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    package="com.xiaoma.threadpooltest"  
    android:versionCode="1"  
    android:versionName="1.0" >  
   
    <uses-sdk  
        android:minSdkVersion="8"  
        android:targetSdkVersion="15" />  
   
    <application  
        android:allowBackup="true"  
        android:icon="@drawable/ic_launcher"  
        android:label="@string/app_name"  
        android:theme="@style/AppTheme" >  
        <activity  
            android:name="Main"  
            android:label="@string/app_name" >  
<!--             <intent-filter> -->  
<!--                 <action android:name="android.intent.action.MAIN" /> -->  
   
<!--                 <category android:name="android.intent.category.LAUNCHER" /> -->  
<!--             </intent-filter> -->  
        </activity>  
        <activity  
            android:name="MyRunnableActivity"  
            android:label="@string/app_name" >  
            <intent-filter>  
                <action android:name="android.intent.action.MAIN" />  
   
                <category android:name="android.intent.category.LAUNCHER" />  
            </intent-filter>  
        </activity>  
    </application>  
   
</manifest>

推荐阅读更多精彩内容