[JAVAee]线程池

ExecutorService pool = Executors.newFixedThreadPool(10);//在线程池中创建10个线程
        pool.submit(new Runnable() {//调用submit方法,给线程们布置任务执行
            @Override
            public void run() {
                System.out.println("wow");
            }
        });
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("haha");
            }
        });

线程池的创建方式

在Executors中线程池的创建大致分四种方法.

①newFixedThreadPool-创建固定线程数目的线程池

②newCachedThreadPool-创建线程数目动态增长的线程池

③newSingleThreadExecutor-创建单线程的线程池

④newScheduleThreadPool-创建可延迟执行命令的线程池(类似Timer)

线程池的解析

①Executors与ThreadPoolExecutor

上述对于线程池的创建的四种方法,其实本质上都是同一种方法:ThreadPoolExecutor.

Executors本质上只是对ThreadPoolExecutor类的封装.

源码:

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }
//在Exeucutors中实例化了一个ScheduledThreadPoolExecutor,这个类继承了ThreadPoolExecutor

可以看到都ThreadPoolExecutor这个类有关,Executors中不同种类的线程池只是在ThreadPoolExecutor传入的参数不同.

选择了要创建哪一种线程池,在Executor中会默认的帮你设定相应的参数.从而让我们更方便的使用.

②ThreadPoolExecutor线程池的构造方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corPoolSize-在线程池中的线程数目,即使线程是空闲的.除非设置了allowCoreThreadTimeOut.
maximumPoolSize-在线程池中允许的最大线程数目(如果线程池中的任务比较多,会暂时创建新的线程来协助完成任务.但这些新创建的线程最后是会被销毁的,所以有最大线程数=最初创建的线程数 + 临时线程数).
keepAliveTime-临时新创建的线程的最大空闲等待新任务的时间,如果时间一到临时创建的线程将会被销毁.
unit-keepAliveTime参数的时间单位.
workQueue-一个阻塞队列,用来管理任务.
threadFactory-工厂模式,辅助线程池创建线程
handler-线程池的拒绝策略(下文会介绍)

③RejectedExecutionHandler线程池的拒绝策略

在ThreadPoolExecutor类中,实现了四个拒绝策略

拒绝的是什么?什么时候会触发拒绝条件?

前面我们提到,通过调用创建Executors的实例化对象的submit方法将任务添加到阻塞队列当中.

当任务数量达到一定的数量,队列中塞满了或者线程池中的每一个线程都在工作没有多余的线程时会触发拒绝条件.

AbortPolicy-抛出一个RejectedExecutionException异常

CallRunsPolicy-将被拒绝的任务返回给提交任务的线程执行

DiscardOldestPolicy-抛弃阻塞队列中队首的任务,并把新任务添加进来

DiscardPolicy-抛弃这个想要新加入的任务

固定线程数量线程池的简单模拟实现

分为:

有一个阻塞队列存放任务
创建相应数量的线程
提供一个submit方法添加任务

public class MyThreadPool extends Thread{
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();//阻塞队列存放任务

    public MyThreadPool(int n){//构造方法,在创建线程池的时候就创建相应数量的线程
        for(int i = 0; i < n; i++){
            Thread thread = new Thread(() -> {
                while(true){
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }

    public void submit(Runnable runnable) throws InterruptedException {//将任务存放到阻塞队列的方法
        queue.put(runnable);
    }

    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(3);
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("wowo");
            }
        });
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("haha");
            }
        });
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

开发语言