12、线程池ThreadPool

1、总共有5种线程池:

  • 1、单个线程

    ExecutorService pool1 = Executors.newSingleThreadExecutor();

  • 2、固定数量线程

    ExecutorService pool2 = Executors.newFixedThreadPool(2);

  • 3、动态线程数量

    ExecutorService pool3 = Executors.newCachedThreadPool();

  • 4、定时调度的线程池,功能和timer一样

    ExecutorService pool4 = Executors.newScheduledThreadPool(2);

    ScheduledThreadPoolExecutor还是继承了ThreadPoolExecutor

  • 5、这个不知道是什么线程池

    ExecutorService pool5 = Executors.newWorkStealingPool();

它们都有execute()、submit()等方法。

在getTask中有这么一段代码

我们执行它的execute()方法其实只是把任务放在它里面的blockingqueue中,这样就会唤醒阻塞的线程拿到task来执行,所以这就需要blockingqueue。这是一个生产者和消费者模型

2、问题:怎么知道queue中的任务怎么运行?

这就需要统一的接口标准,往里面扔的任务必须implements Runable接口才行(为什么?)

因为:只要实现了Runable/callable接口,就必须实现一个run/call方法,这样线程池中的线程就可以直接调用run或者call方法,执行业务。

注意:传入进去的Runnable任务,不会以线程的形式运行。

3、代码实例:

import java.util.ArrayList;
import java.util.concurrent.*;

/**
 * Executors创建线程池
 * ThreadPoolExecutor创建线程池
 *
 * 类的关系
 * class ThreadPoolExecutor extends AbstractExecutorService
 *
 * class AbstractExecutorService implements ExecutorService
 *
 * interface ExecutorService extends Executor
 *
 * [@Author](https://my.oschina.net/arthor) liufu
 * @CreateTime 2018/5/10  15:24
 */
public class ThreadPoolExecutorTest {
    public static void main(String[] args) {

        ExecutorService pool1 = Executors.newFixedThreadPool(2);
        ExecutorService pool2 = Executors.newCachedThreadPool();
        ExecutorService pool3 = Executors.newScheduledThreadPool(2);
        ExecutorService pool4 = Executors.newSingleThreadExecutor();
        ExecutorService pool5 = Executors.newWorkStealingPool();

       //Executors.newXX其实就是创建了new ThreadPoolExecutor()对象,里面传入对应的值而已
       //推荐使用这种方式,对资源好控制
        ExecutorService executor = new ThreadPoolExecutor(2,  //最小线程数        
                2,                         //最大线程数
                0L,                         //执行超时,0L,表示不超时
                TimeUnit.MILLISECONDS,                      //时间为分钟
                new ArrayBlockingQueue<Runnable>(10));        //任务队列的大小

        ArrayList<Runnable> runnables = new ArrayList<>();
        pool1.shutdown();
        //这个就是生产者!!
        for (int i = 0; i < 100; i++) {
            runnables.add(new Runnable() {
                [@Override](https://my.oschina.net/u/1162528)
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                        Thread.sleep(5000);
                        System.out.println("工作完成!!");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }

        //消费者!!!
        for (Runnable runnable : runnables) {
            pool1.execute(runnable);
        }

        //主线程是不等待线程池的。
        System.out.println("早就执行完了,不等待线程池的处理了");
    }
}

4、线程池示意图

5、问题

  • 1、为什么需要线程池?

    这个和连接池一样,为了避免频繁的创建和销毁线程池带来的性能损耗。

  • 2、它的execute()方法其实只是把任务放在它里面的BlookingQueue中,然后线程池里面的线程来获取任务执行,如果queue中没有任务就阻塞。

  • 3、线程池创建的方式

  • 3.1、Excutors

    内部new ThreadPoolExcutor(),而且那个任务队列queue是没有指定大小的,默认是Integer.MAX_VALUE = 42亿,如果线程处理的慢,就会导致queue堆满42亿任务对象,会出现内存溢出问题,GC没法扫。

  • 3.2、new ThreadPoolExcutor()这种比较自主可控,里面有7个参数

    • 前面5个比较常用分别是:

        最小线程
        最大线程
        过期时间
        时间单位
        queue(要指定大小)
      
    • 后面是:

        ThreadFactory(可以给线程加名字)
        RejectedExecutionHandler(拒绝执行时的回调)。
      
    • RejectedExecutionHandler已经有好几种实现

        ● AbortPolicy
        ● DiscardPolicy
        ● DiscardOldestPolicy
        ● CallerRunsPolicy
        ● 自定义
      

评论

暂无评论