java线程池

来源：互联网发布：淘宝好评语30字编辑：程序博客网时间：2024/05/10 05:21

文章链接

线程池

ThreadPoolExecutor的介绍
Executors工厂类的介绍

ThreadPoolExecutor介绍

基础API的介绍
- isShutdown() ：判断线程池是否关闭
- isTerminated() : 判断线程池中任务是否执行完成
- shutdown() : 调用后不再接收新任务，如果里面有任务，就执行完
- shutdownNow() : 调用后不再接受新任务，如果有等待任务，移出队列；有正在执行的，尝试停止之
- submit() : 提交执行任务
- execute() : 执行任务
构造相关的介绍
- corePoolSize : 核心工作的线程个数
- maximumPoolSize : 最大线程个数
- keepAliveTime : 额外线程空闲的时间
- unit : keepAliveTime的单位
- workQueue ：任务队列参考BlockingQueue
- threadFactory : 线程工厂，如何去创建线程的
- handler ：任务队列添加异常的捕捉器，参考 RejectedExecutionHandler

阻塞队列的介绍（BlockingQueue）

阻塞队列，如果BlockingQueue是空的，从BlockingQueue取东西的操作将会被阻断进入等待状态，直到BlockingQueue进了东西才会被唤醒，同样，如果BlockingQueue是满的，任何试图往里存东西的操作也会被阻断进入等待状态，直到BlockingQueue里有空间时才会被唤醒继续操作。

基础API介绍
- 往队列中加元素的方法
  - add(E) : 非阻塞方法, 把元素加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
  - offer(E) : 非阻塞, 表示如果可能的话，将元素加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
  - put(E)：阻塞方法，把元素加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
- 从队列中取元素的方法
  - poll(time)：阻塞方法，取走BlockingQueue里排在首位的元素，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。
  - take()：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。
子类介绍
- ArrayBlockingQueue ： FIFO 队列，规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小
- LinkedBlockingQueue：FIFO 队列，大小不定的BlockingQueue，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。
- PriorityBlockingQueue：优先级队列，类似于LinkedBlockingQueue，但队列中元素非 FIFO, 依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序
- SynchronousQueue: 交替队列，队列中操作时必须是先放进去，接着取出来，交替着去处理元素的添加和移除

RejectedExecutionHandler介绍

实现的子类介绍 * ThreadPoolExecutor.AbortPolicy > 当添加任务出错时的策略捕获器，如果出现错误，则直接抛出异常

ThreadPoolExecutor.CallerRunsPolicy
当添加任务出错时的策略捕获器，如果出现错误，直接执行加入的任务
ThreadPoolExecutor.DiscardOldestPolicy
当添加任务出错时的策略捕获器,如果出现错误,移除第一个任务,执行加入的任务
ThreadPoolExecutor.DiscardPolicy
当添加任务出错时的策略捕获器，如果出现错误，不做处理

import java.util.concurrent.BlockingQueue;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.RejectedExecutionHandler;import java.util.concurrent.ThreadFactory;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;/* *  @项目名：  *  @包名：    *  @文件名:   ThreadManager *  @创建者:   Administrator *  @创建时间:  2015/11/23 11:27 *  @描述：    线程管理类，管理线程池，一个应用中有多个线程池，每个线程池做自己相关的业务 */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);            }        }    }}

0 0