线程池原理剖析一

线程池原理剖析一

线程池的好处

1：复用线程，降低线程创建销毁导致的资源浪费。
2：提高系统响应速度，任务到达时，不需要等待创建线程。
3：提高线程的可管理性。

线程池的提交策略

向池中提交一个任务的大致流程如下：
1：判断核心线程池的线程是否已满。如果不是则创建一个工作线程执行该任务（需获取全局锁）。如果已满则进2.
2：判断任务队列是否已满，如果未满，则把当前任务存入队列，如果队列已满，则进3.
2：判断线程池（maximumPoolSize）是否已满，如果未满，则创建一个工作线程执行该任务（需获取全局锁），如果已满执行饱和策略。

ThreadPoolExecutor采取上述步骤的总体设计思路，是为了在执行execute()方法时，尽可能
地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在ThreadPoolExecutor完成预热之后
（当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法调用都是执行步骤2，而
步骤2不需要获取全局锁。

如下图所示：

线程池例子

部分参数说明

		the number of threads to keep in the pool, even if they are idle
        池中线程的数量，空闲的线程也算
        int corePoolSize

        the maximum number of threads to allow in the pool
        池中允许的最大线程数量
        int maximumPoolSize

        when the number of threads is greater than the core, this is the maximum
        time that excess idle threads will wait for new tasks before terminating.
        当线程数量大于corePoolSize时，如果超过 keepAliveTime 还没有新的任务，则释放大于 corePoolSize 部分的线程
        long keepAliveTime

        TimeUnit unit 时间单位
        BlockingQueue<Runnable> workQueue 工作队列
        ThreadFactory threadFactory 线程工厂
        RejectedExecutionHandler handler 拒绝策略
        {
            AbortPolicy 默认是这个 抛出异常
            CallerRunsPolicy 不抛弃任务，不抛异常，将任务回退给调用者
            DiscardPolicy 丢弃任务
            DiscardOldestPolicy 丢弃队列等待最久的任务
        }

线程池代码

		//线程工厂
 		ThreadFactory factory = new ThreadFactory() {
            AtomicInteger atomic = new AtomicInteger(1);
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r,"MyThread--"+atomic.getAndIncrement());
                return thread;
            }
        };
		
        ThreadPoolExecutor exec = new ThreadPoolExecutor
                (5,
                10,
                0,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(),
                factory,
                new ThreadPoolExecutor.AbortPolicy());
        
        for(int i = 1;i<20;i++){
            final int  j= i;
            exec.execute(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        System.out.println(Thread.currentThread().getName()+"  "+j);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }

参考书籍

java并发编程的艺术

这一篇博文只是初步探索线程池，在后续文章里我尽量保证以通俗易懂的方式继续介绍线程池。