java线程池

 文章链接

线程池

• 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里有空间时才会被唤醒继续操作。

1. 基础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有新的对象被加入为止。

2. 子类介绍

   • 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);
            }
        }

    }

}