Java并发编程:Java的四种线程池的使用,以及自己设置线程工厂

作者 : 开心源码 本文共5913个字,预计阅读时间需要15分钟 发布时间: 2022-05-12 共178人阅读

引言

通过前面的文章,我们学习了Executor框架中的核心类ThreadPoolExecutor ,对于线程池的核心调度机制有了肯定的理解,并且成功使用ThreadPoolExecutor 创立了线程池。

而在Java中,除了ThreadPoolExecutor ,Executor框架中还提供了四种线程池,这四种线程池都是直接或者间接配置ThreadPoolExecutor的参数实现的,对于ThreadPoolExecutor类不熟习的读者可以参考Java并发编程:Java线程池核心ThreadPoolExecutor的使用和原理分析

四种线程池

四种线程池分别是:newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ,下面对这几个线程池逐个讲解。

newCachedThreadPool:可缓存的线程池

源码:

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

newCachedThreadPool的方法中是返回一个ThreadPoolExecutor实例,从源码中可以看出该线程池的特点:

1、该线程池的核心线程数量是0,线程的数量最高可以达到Integer 类型最大值;

2、创立ThreadPoolExecutor实例时传过去的参数是一个SynchronousQueue实例,说明在创立任务时,若存在空闲线程就复用它,没有的话再新建线程。

3、线程处于闲置状态超过60s的话,就会被销毁。

用法:

public static void main(String[] args) {    //定义ExecutorService实例    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();    for (int i = 0; i < 10; i++) {        final int index = i;        try {            Thread.sleep(index * 1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        //调用execute方法        cachedThreadPool.execute(new Runnable() {            @Override            public void run() {                System.out.println(Thread.currentThread() + ":" + index);            }        });    }}

上面的代码由于每次循环都是隔一秒执行,这个时间足够之前的线程工作完毕,并在新循环中复用这个线程,程序的运行结果如下:

Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-1,5,main]:1Thread[pool-1-thread-1,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-1,5,main]:4Thread[pool-1-thread-1,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-1,5,main]:7Thread[pool-1-thread-1,5,main]:8Thread[pool-1-thread-1,5,main]:9

newFixedThreadPool:定长线程池

源码:

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

线程池特点:

1、线程池的最大线程数等于核心线程数,并且线程池的线程不会由于闲置超时被销毁。

2、使用的列队是LinkedBlockingQueue,表示假如当前线程数小于核心线程数,那么即便有空闲线程也不会复用线程去执行任务,而是创立新的线程去执行任务。假如当前执行任务数量大于核心线程数,此时再提交任务就在队列中等待,直到有可用线程。

用法:

public static void main(String[] args) {    ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3);    for (int i = 0; i < 10; i++) {        final int index = i;        try {            Thread.sleep(index * 1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        cachedThreadPool.execute(new Runnable() {            @Override            public void run() {                System.out.println(Thread.currentThread() + ":" + index);            }        });    }}

定义一个线程数为3的线程池,循环10次执行,可以发现运行的线程永远只有三个,结果如下:

Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-2,5,main]:1Thread[pool-1-thread-3,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-2,5,main]:4Thread[pool-1-thread-3,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-2,5,main]:7Thread[pool-1-thread-3,5,main]:8Thread[pool-1-thread-1,5,main]:9

newSingleThreadExecutor:单线程线程池

源码:

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

从源码即可以看出,该线程池基本就是只有一个线程数的newFixedThreadPool,它只有一个线程在工作,所有任务按照指定顺序执行。

用法:

和newFixedThreadPool相似,只是一直只有一个线程在工作,这里就不贴代码了。

newScheduledThreadPool:支持定时的定长线程池

源码:

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {    return new ScheduledThreadPoolExecutor(corePoolSize);}public ScheduledThreadPoolExecutor(int corePoolSize) {        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,              new DelayedWorkQueue());}public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), defaultHandler);    }

newScheduledThreadPool的方法不是直接返回一个ThreadPoolExecutor实例,而是通过有定时功能的ThreadPoolExecutor,也就是ScheduledThreadPoolExecutor 来返回ThreadPoolExecutor实例,从源码中可以看出:

1、该线程池可以设置核心线程数量,最大线程数与newCachedThreadPool一样,都是Integer.MAX_VALUE。

2、该线程池采用的队列是DelayedWorkQueue,具备推迟和定时的作用。

用法:

public static void main(String[] args) {    ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);    //推迟3秒执行,只执行一次    ((ScheduledExecutorService) scheduledThreadPool).schedule(new Runnable() {        @Override        public void run() {            System.out.println("推迟========");        }    },3,TimeUnit.SECONDS);    //推迟1秒后每隔两秒执行一次    ((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(new Runnable() {        @Override        public void run() {            System.out.println("执行============");        }    },1,2,TimeUnit.SECONDS);            //单位是秒}

自己设置ThreadFactory

四种线程池的使用就说到这里了,值得说明的是,除了上面的参数外,Executors类中还给这四种线程池提供了可传ThreadFactory的重载方法,以下是它们的源码:

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {    return new FinalizableDelegatedExecutorService        (new ThreadPoolExecutor(1, 1,                                0L, TimeUnit.MILLISECONDS,                                new LinkedBlockingQueue<Runnable>(),                                threadFactory));}public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                60L, TimeUnit.SECONDS,                                new SynchronousQueue<Runnable>(),                                threadFactory);}public static ScheduledExecutorService newScheduledThreadPool(                int corePoolSize, ThreadFactory threadFactory) {    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);}public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue<Runnable>(),                                      threadFactory);}    

ThreadFactory是一个接口类,也就是我们经常说的线程工厂,只有一个方法,可以用于创立线程:

Thread newThread(Runnable r);

默认情况下,ThreadPoolExecutor构造器传入的ThreadFactory 参数是Executors类中的defaultThreadFactory(),相当于一个线程工厂,帮我们创立了线程池中所需的线程。

除此之外,我们也可以自己设置ThreadFactory,并根据自己的需要来操作线程,下面是实例代码:

public static void main(String[] args) {    ExecutorService service = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,            new SynchronousQueue<Runnable>(), new ThreadFactory() {        @Override        public Thread newThread(Runnable r) {            Thread t = new Thread(r);            System.out.println("我是线程" + r);            return t;        }    }    );    //用lambda表达式编写方法体中的逻辑    Runnable run = () -> {        try {            Thread.sleep(1000);            System.out.println(Thread.currentThread().getName() + "正在执行");        } catch (InterruptedException e) {            e.printStackTrace();        }    };    for (int i = 0; i < 5; i++) {        service.submit(run);    }    //这里肯定要做关闭    service.shutdown();}

运行代码后,控制行会输出五行 “我是线程java.util.concurrent.ThreadPoolExecutor。。。。。”的信息,也证实了我们自己设置的ThreadFactory起到了作用。

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » Java并发编程:Java的四种线程池的使用,以及自己设置线程工厂

发表回复