线程池的使用

来源：互联网发布：车床圆弧编程编辑：程序博客网时间：2024/06/11 05:01

一.为什么使用线程池(why)

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。线程池是对线程的一种封装，让线程用起来更加简便，只需要创一个线程池，把这些步骤像任务一样放进线程池，在程序销毁时只要调用线程池的销毁函数即可与直接开启线程:new Thread的弊端如下：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能

二.什么是线程池,线程池的种类(whata)

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。

三.AsyncTask中线程池的使用

AsyncTask内部实现了两个线程池，分别是：串行线程池和固定线程数量的线程池。而这个固定线程数量则是通过CPU的数量决定的。

private static final int CORE_POOL_SIZE = CPU_COUNT + 1;private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

1.task.executeOnExecuto(AsyncTask.THREAD_POOL_EXECUTOR);执行固定个数的线程个数

2.task.execute();//系统默认的开启一条线程,完成后在执行其他.
线程池内部使用的hangdler是静态的,因此在安卓程序中,所有的对象会共用一个线程池
3.使用自定义的线程池

task.executeOnExecutor(Executors.newFixedThreadPool(5));task.executeOnExecutor(Executors.newSingleThreadExecutor());task.executeOnExecutor(Executors.newCachedThreadPool());

四.使用线程池.

1.定义一个线程池类

public class ThreadManager {    private static ThreadPoolProxy mNormalPool   = new ThreadPoolProxy(3, 3, 5 * 1000);    private static ThreadPoolProxy mDownloadPool = new ThreadPoolProxy(3, 3, 5 * 1000);    public static ThreadPoolProxy getNormalPool() {        return mNormalPool;    }    public static ThreadPoolProxy getDownloadPool() {        return mDownloadPool;    }    public static class ThreadPoolProxy {        private final int                mCorePoolSize;        private final int                mMaximumPoolSize;        private final long               mKeepAliveTime;        private       ThreadPoolExecutor mPool;        public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {            this.mCorePoolSize = corePoolSize;            this.mMaximumPoolSize = maximumPoolSize;            this.mKeepAliveTime = keepAliveTime;        }        private void initPool() {            if (mPool == null || mPool.isShutdown()) {                //                int corePoolSize = 1;//核心线程池大小                //                int maximumPoolSize = 3;//最大线程池大小                //                long keepAliveTime = 5 * 1000;//保持存活的时间                TimeUnit                unit      = TimeUnit.MILLISECONDS;//单位                BlockingQueue<Runnable> workQueue = null;//阻塞队列                //                workQueue = new ArrayBlockingQueue<Runnable>(3);//FIFO,大小有限制                workQueue = new LinkedBlockingQueue();//                //                workQueue = new PriorityBlockingQueue();                ThreadFactory threadFactory = Executors.defaultThreadFactory();//线程工厂                RejectedExecutionHandler handler = null;//异常捕获器                //                handler = new ThreadPoolExecutor.DiscardOldestPolicy();//去掉队列中首个任务，将新加入的放到队列中去                //                handler = new ThreadPoolExecutor.AbortPolicy();//触发异常                handler = new ThreadPoolExecutor.DiscardPolicy();//不做任何处理                //                handler = new ThreadPoolExecutor.CallerRunsPolicy();//直接执行，不归线程池控制,在调用线程中执行                //                new Thread(task).start();                mPool = new ThreadPoolExecutor(mCorePoolSize,                                               mMaximumPoolSize,                                               mKeepAliveTime,                                               unit,                                               workQueue,                                               threadFactory,                                               handler);            }        }        /**         * 执行任务         * @param task         */        public void execute(Runnable task) {            initPool();            //执行任务            mPool.execute(task);        }        public Future<?> submit(Runnable task) {            initPool();            return mPool.submit(task);        }        public void remove(Runnable task) {            if (mPool != null && !mPool.isShutdown()) {                mPool.getQueue()                     .remove(task);            }        }    }}
2.使用

public class MainActivity extends AppCompatActivity {    private Handler mHandler = new Handler() {        @Override        public void handleMessage(Message msg) {            switch (msg.what) {                case 0:                    Toast.makeText(MainActivity.this, "收到", Toast.LENGTH_SHORT).show();                     break;                case 1:                    Toast.makeText(MainActivity.this, "下载完成", Toast.LENGTH_SHORT).show();                     break;            }        }    };    private ThreadManager.ThreadPoolProxy mPool;    private ThreadManager.ThreadPoolProxy mDownloadPool;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        //得到一个普通线程        mPool = ThreadManager.getNormalPool();        //创建一个下载线程        mDownloadPool = ThreadManager.getDownloadPool();    }    public void startNormal (View view){        mPool.execute(new MyTask());    }    public void startDownLoad(View view){        mDownloadPool.execute(new MyDownLoad());    }    private class MyTask implements Runnable {        @Override        public void run() {            SystemClock.sleep(2000);            mHandler.sendEmptyMessage(0);        }    }    private class MyDownLoad implements Runnable{        @Override        public void run() {            SystemClock.sleep(3000);            mHandler.sendEmptyMessage(1);        }    }}
在AsyncTask使用,见源码Demo

源码下载

0 0