多线程之线程池

最新推荐文章于 2022-05-20 15:14:59 发布

Rick1993

最新推荐文章于 2022-05-20 15:14:59 发布

阅读量225

点赞数

分类专栏：多线程文章标签：多线程线程池

本文链接：https://blog.csdn.net/thqtzq/article/details/95013845

版权

多线程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

前言：

系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互。在这种情形下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。
与数据库连接池类似的是，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池时，线程池就会启动一个线程来执行它们的run()或者call()方法；当run()或者call()方法执行结束后，该线程并不会死亡，而是再次返回到线程池中成为空闲状态，等待执行下一个Runnable对象的run()方法或Callable对象的call()方法。
除此之外，使用线程池可以有效地控制系统中并发线程的数量，当系统中包含大量并发线程时，会占用大量系统资源，导致系统性能急剧下降，甚至导致JVM崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过次数。

Java 5新增了一个Executors工厂类来生产线程池，该工厂类包含如下几个静态工厂方法来创建线程池：

newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中

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

2，newFixedThreadPool(int nThreads) : 创建一个可重用的，具有固定线程池数的线程池。

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

3，newSingleThreadExecutor() : 创建一个只有单线程的线程池，它相当于调用newFixedThreadPool()方法时传入参数为1。

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

4，newScheduledThreadPool(int corePoolSize) : 创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。corePoolSize指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。

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

5，newSingleThreadScheduledExecutor() : 创建只有一个线程的线程池，它可以在指定延迟后执行线程任务。

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

6，newWorkStealingPool(int parallelism) : 创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争。

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

7，newWorkStealingPool(): 该方法是前一个方法的简化版本，如果当前机器有4个CPU，则目标并行级别被设置为4，也就是相当于为前一个方法传入4作为参数。

public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

小结：

上面7个方法，前三个返回一个ExecutorService对象，该对象改变一个线程池，它可以执行Runnable对象或Callable对象代表的线程；第4和5个方法返回一个ScheduledExecutorService线程池，他是ExecutorService的子类，它可以在指定延迟后执行线程任务；最后2个方法时Java 8新增的，这两个方法可充分利用多CPU的并行能力。这两个方法生成的work stealing池，都相当于后台线程池，如果所有的前台线程都死亡了，work Stealing池中的线程会自动死亡。
ExecutorService代表尽快执行线程的线程池，程序只要将一个Runnable对象或Callable对象提交给该线程池，该线程池就会尽快执行该任务。
ScheduledExecutorService代表可在指定延迟后或周期性的执行线程任务的线程池，它有如下4个方法：

package java.util.concurrent;

public interface ScheduledExecutorService extends ExecutorService {
	//1，指定runnable任务将在delay延迟后执行
    ScheduledFuture<?> schedule(Runnable var1, long delay, TimeUnit var4);

	//2，指定callable任务将在delay延迟后执行
    <V> ScheduledFuture<V> schedule(Callable<V> var1, long delay, TimeUnit var4);

	//3，指定command任务将在delay延迟后执行，而且以设定的频率重复执行；如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行。
    ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long delay, long var4, TimeUnit var6);

	//4，指定command任务在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务的任一执行遇到异常，就会取消后续执行。否则，只能通过执行程序的取消或终止方法来终止该任务。
    ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long delay, long var4, TimeUnit var6);
}

用完一个线程池后，应该调用该线程池的shutdown()方法，该方法将启动线程池的关闭序列，调用shutdown()方法后的线程池不会再接受新的任务，但会将以前所有已提交的任务执行完毕；当线程池中的所有任务都执行完毕后，池中的所有线程都会死亡。

上述4个方法的演示代码如下：
schedule方法的演示：

package com.dalingjia.threadpool;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExcutorTest {

    private static ScheduledThreadPoolExecutor stpe = null;

    private static int index = 0;

    private static String getTime(){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return df.format(new Date());
    }

    public static void main(String[] args) {
        System.out.println(getTime());
        //构造一个ScheduledThreadPoolExecutor对象，并且设置它的容量为5个
        stpe = new ScheduledThreadPoolExecutor(5);
        //隔2秒后执行一次，但只会执行一次；此时线程池不会关闭
        stpe.schedule(() -> {
            index++;
            System.out.println(getTime() + "*********" + index);
            if (index >= 10){
                stpe.shutdown();
                if (stpe.isShutdown()){
                    System.out.println("停止了！！！");
                }
            }
        }, 2, TimeUnit.SECONDS);
    }
}

scheduleAtFixedRate方法演示： 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。如果任务的任何一个执行遇到异常，则后续执行都会被取消。否则，只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行

package com.dalingjia.threadpool;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExcutorTest {

    private static ScheduledThreadPoolExecutor stpe = null;

    private static int index = 0;

    private static String getTime(){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return df.format(new Date());
    }

    public static void main(String[] args) {
        System.out.println(getTime());
        //构造一个ScheduledThreadPoolExecutor对象，并且设置它的容量为5个
        stpe = new ScheduledThreadPoolExecutor(5);
        //2秒后开始执行，并以1秒的频率重复执行
        stpe.scheduleAtFixedRate(() -> {
            index++;
            System.out.println(getTime() + "*********" + index);
            try {
                //如果此任务的任何一个执行要花费比其周期更长的时间，则将 推迟后续执行，但不会同时执行；所以下次执行要等3秒
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (index >= 10){
                stpe.shutdown();
                if (stpe.isShutdown()){
                    System.out.println("停止了！！！");
                }
            }
        }, 2, 1, TimeUnit.SECONDS);
    }
}

scheduleWithFixedDelay方法演示：

package com.dalingjia.threadpool;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExcutorTest {

    private static ScheduledThreadPoolExecutor stpe = null;

    private static int index = 0;

    private static String getTime(){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return df.format(new Date());
    }

    public static void main(String[] args) {
        System.out.println(getTime());
        //构造一个ScheduledThreadPoolExecutor对象，并且设置它的容量为5个
        stpe = new ScheduledThreadPoolExecutor(5);
        //隔3秒后开始执行任务，随后，在每一次执行终止后，隔1秒开始下一次执行
        stpe.scheduleWithFixedDelay(() -> {
            index++;
            System.out.println(getTime() + "\t" + index);
            try {
                //验证执行终止后，隔一秒开始下一次执行
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (index >= 10){
                //启动线程池的关闭序列
                stpe.shutdown();
                if (stpe.isShutdown()){
                    System.out.println("停止了！！！");
                }
            }
        } ,3, 1, TimeUnit.SECONDS);
    }
}