JAVA多线程基础、JDK提供5种线程池的创建和使用、放弃JDK提供5种线程池使用ThreadPoolExecutor来创建线程池(推荐)

最新推荐文章于 2024-07-29 16:34:58 发布

刘贤松

最新推荐文章于 2024-07-29 16:34:58 发布

阅读量473

点赞数 1

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

本文链接：https://blog.csdn.net/qq_15371293/article/details/110125327

版权

多线程专栏收录该内容

4 篇文章 1 订阅

订阅专栏

前言

Java是天生就支持并发的语言，支持并发意味着多线程，线程的频繁创建在高并发及大数据量是非常消耗资源的，因此java提供了线程池。线程池好处：线程是稀缺资源，如果被无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，合理的使用线程池对线程进行统一分配、调优和监控，有以下好处：

降低资源消耗；
提高响应速度；
提高线程的可管理性；

在jdk1.5以前的版本中，线程池的使用是及其简陋的，但是在JDK1.5后，有了很大的改善。JDK1.5之后加入了java.util.concurrent包，java.util.concurrent包的加入给予开发人员开发并发程序以及解决并发问题很大的帮助。这篇文章主要介绍下并发包下的Executor接口，Executor接口虽然作为一个非常旧的接口（JDK1.5 2004年发布） Executor框架的最顶层实现是ThreadPoolExecutor类，Executors工厂类中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool方法其实也只是ThreadPoolExecutor的构造函数参数不同而已。

通过传入不同的参数，就可以构造出适用于不同应用场景下的线程池，那么它的底层原理是怎样实现的呢，这篇就来介绍下ThreadPoolExecutor线程池的运行过程。corePoolSize：核心池的大小。当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程； keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性；

提示：以下是本篇文章正文内容，下面案例可供参考

一、多线程相关问题

1) 什么是线程？

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。

2) 线程和进程有什么区别？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。

3) 如何在Java中实现线程？

在语言层面有两种方式。java.lang.Thread 类的实例就是一个线程但是它需要调用java.lang.Runnable接口来执行，由于线程类本身就是调用的Runnable接口所以你可以继承java.lang.Thread 类或者直接调用Runnable接口来重写run()方法实现线程。

4) 用Runnable还是Thread？

这个问题是上题的后续，大家都知道我们可以通过继承Thread类或者调用Runnable接口来实现线程，问题是，那个方法更好呢？什么情况下使用它？这个问题很容易回答，如果你知道Java不支持类的多重继承，但允许你调用多个接口。所以如果你要继承其他类，当然是调用Runnable接口好了。

6) Thread 类中的start() 和 run() 方法有什么区别？

这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

7) Java中Runnable和Callable有什么不同？

Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。

8) Java中CyclicBarrier 和 CountDownLatch有什么不同？

CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是，CountdownLatch 不能重新使用。

二、5种线程池的创建方法和作用

1.newCachedThreadPool

作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。
特征：

线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）
当线程池中，没有可用线程，会重新创建一个线程

创建方式： Executors.newCachedThreadPool();

代码如下（示例）：

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * @author liuxiansong
 * 创建一个 Executors.newCachedThreadPool 可缓存线程池，应用中存在的线程数可以无限大
 */
public class NewCachedThreadPool {

    public static void main(String[] args) {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        System.out.println("创建一个 Executors.newCachedThreadPool 可缓存线程池，应用中存在的线程数可以无限大");
        for (int i = 0; i <= 5; i++) {

            newCachedThreadPool.execute(new ThreadPools(i));
        }
    }
}


class ThreadPools implements Runnable {

    private Integer index;

    public ThreadPools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！" + index);
            Thread.sleep(index * 100);
            System.out.printf("线程标识: %s，线程名: %s \n", this.toString(), Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行如下（示例）：

2.newFixedThreadPool

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
特征：

线程池中的线程处于一定的量，可以很好的控制线程的并发量
线程可以重复被使用，在显示关闭之前，都将一直存在
超出一定量的线程被提交时候需在队列中等待

创建方式：

Executors.newFixedThreadPool(int nThreads)；//nThreads为线程的数量
Executors.newFixedThreadPool(int nThreads，ThreadFactory threadFactory)；//nThreads为线程的数量，threadFactory创建线程的工厂方式

代码如下（示例）：

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * @author liuxiansong
 * 创建一个 Executors.newFixedThreadPool 可缓存线程池，应用中存在的线程数可以无限大
 */
public class NewFixedThreadPool {

    public static void main(String[] args) {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        System.out.println("创建一个 Executors.newFixedThreadPool 可缓存线程池，应用中存在的线程数可以无限大");
        for (int i = 0; i <= 5; i++) {
            newFixedThreadPool.submit(new ThreadPools(i));
        }
        newFixedThreadPool.shutdown();
    }
}


class ThreadPools implements Runnable {

    private Integer index;

    public ThreadPools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！" + index);
            Thread.sleep(index * 100);
            System.out.printf("线程标识: %s，线程名: %s \n", this.toString(), Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行如下（示例）：

3.newSingleThreadExecutor

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
特征：

线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行

创建方式：

Executors.newSingleThreadExecutor() ；
Executors.newSingleThreadExecutor(ThreadFactory threadFactory)；// threadFactory创建线程的工厂方式

代码如下（示例）：

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 * @author liuxiansong
 * 创建一个 Executors.newSingleThreadExecutor 可缓存线程池，应用中存在的线程数可以无限大
 */
public class NewSingleThreadExecutor {

    public static void main(String[] args) {
        ExecutorService newFixedThreadPool = Executors.newSingleThreadExecutor();
        System.out.println("创建一个 Executors.newSingleThreadExecutor 可缓存线程池，应用中存在的线程数可以无限大");
        for (int i = 0; i <= 5; i++) {
            newFixedThreadPool.execute(new ThreadPools(i));
        }
        newFixedThreadPool.shutdown();
    }
}


class ThreadPools implements Runnable {

    private Integer index;

    public ThreadPools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！" + index);
            Thread.sleep(index * 100);
            System.out.printf("线程标识: %s，线程名: %s \n", this.toString(), Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行如下（示例）：

4.newScheduledThreadPool

作用：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
特征：

线程池中具有指定数量的线程，即便是空线程也将保留
可定时或者延迟执行线程活动

创建方式：

Executors.newScheduledThreadPool(int corePoolSize)；// corePoolSize线程的个数
newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)；// corePoolSize线程的个数，threadFactory创建线程的工厂

代码如下（示例）：

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


/**
 * @author liuxiansong
 * 创建一个 Executors.newScheduledThreadPool 可缓存线程池，应用中存在的线程数可以无限大
 */
public class NewScheduledThreadPool {

    public static void main(String[] args) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println("创建一个 Executors.newScheduledThreadPool 可缓存线程池，应用中存在的线程数可以无限大");
        for (int i = 0; i <= 5; i++) {
            newScheduledThreadPool.schedule(new ThreadPools(i), 1, TimeUnit.SECONDS);
            // 10 秒后执行
            newScheduledThreadPool.schedule(new ThreadPools(i), 10, TimeUnit.SECONDS);
        }
        newScheduledThreadPool.shutdown();
    }
}


class ThreadPools implements Runnable {

    private Integer index;

    public ThreadPools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！" + index);
            Thread.sleep(index * 100);
            System.out.printf("线程标识: %s，线程名: %s \n", this.toString(), Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行如下（示例）：

5.newSingleThreadScheduledExecutor

作用：创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
特征：

线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行
可定时或者延迟执行线程活动

创建方式：

Executors.newSingleThreadScheduledExecutor() ；
Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ；//threadFactory创建线程的工厂

代码如下（示例）：

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


/**
 * @author liuxiansong
 * 创建一个 Executors.newSingleThreadScheduledExecutor 可缓存线程池，应用中存在的线程数可以无限大
 */
public class NewSingleThreadScheduledExecutor {

    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

        System.out.println("创建一个 Executors.newSingleThreadScheduledExecutor");
        for (int i = 0; i <= 5; i++) {
            scheduledExecutorService.schedule(new ThreadPools(i), 1, TimeUnit.SECONDS);
            // 10 秒后执行
            scheduledExecutorService.schedule(new ThreadPools(i), 10, TimeUnit.SECONDS);
        }
        scheduledExecutorService.shutdown();
    }
}


class ThreadPools implements Runnable {

    private Integer index;

    public ThreadPools(Integer index) {
        this.index = index;
    }

    @Override
    public void run() {
        /***
         * 业务......省略
         */
        try {
            System.out.println("开始处理线程！！！" + index);
            Thread.sleep(index * 100);
            System.out.printf("线程标识: %s，线程名: %s \n", this.toString(), Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行如下（示例）：

三、(推荐)ThreadPoolExecutor来创建线程池

1、源码分析 ,`ThreadPoolExecutor` 的构造函数

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

构造函数参数

corePoolSize 核心线程数大小，当线程数 < corePoolSize ，会创建线程执行 runnable
maximumPoolSize 最大线程数，当线程数 >= corePoolSize的时候，会把 runnable 放入 workQueue中
keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。
unit 时间单位
workQueue 保存任务的阻塞队列
threadFactory 创建线程的工厂

2、`ThreadPoolExecutor` 实现原理

提交一个任务到线程池中，线程池的处理流程如下：

判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

采用ThreadPoolExecutor创建的优点：

可以实时获取线程池内线程的各种状态
可以动态调整线程池大小

代码如下（示例）：

package com.example.demo.pool;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author liuxiansong888
 */
public class ThreadPool {

    public static void main(String[] args) {

        long currentTimeMillis = System.currentTimeMillis();

        // 构造一个线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5,
                6,
                3,
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3)
        );

        for (int i = 1; i <= 10; i++) {
            try {
                String task = "task=" + i;
                System.out.println("创建任务并提交到线程池中：" + task);
                threadPool.execute(new ThreadPoolTask(task));
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        try {
            //等待所有线程执行完毕当前任务。
            threadPool.shutdown();
            boolean loop = true;
            do {
                //等待所有线程执行完毕当前任务结束，等待2秒
                loop = !threadPool.awaitTermination(2, TimeUnit.SECONDS);
            } while (loop);
            if (!loop) {
                System.out.println("所有线程执行完毕");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("耗时：" + (System.currentTimeMillis() - currentTimeMillis));
        }

    }

}


class ThreadPoolTask implements Runnable, Serializable {

    private Object attachData;
    ThreadPoolTask(Object tasks) {
        this.attachData = tasks;
    }
    @Override
    public void run() {
        try {
            System.out.println("开始执行任务：" + attachData + "任务，使用的线程池，线程名称：" + Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
        attachData = null;
    }
}

运行如下（示例）：

参考文章:

https://blog.csdn.net/weixin_35982425/article/details/82704987

https://www.cnblogs.com/2549372994jing/p/11452648.html

https://www.toutiao.com/i6490300018983961102/

总结

提示：现在做开发的同学，越来越多的人在创建线程池用ThreadPoolExecutor，而不是用JDK提供的五种方法来创建。
阿里编码规约 ：线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

Positive example 1：
//org.apache.commons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
Positive example 2：
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();

//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
Positive example 3：
<bean id="userThreadPool"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="2000" />

<property name="threadFactory" value= threadFactory />
<property name="rejectedExecutionHandler">
<ref local="rejectedExecutionHandler" />
</property>
</bean>
//in code
userThreadPool.execute(thread);

刘贤松

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA多线程基础、JDK提供5种线程池的创建和使用、放弃JDK提供5种线程池使用ThreadPoolExecutor来创建线程池(推荐)

前言Java是天生就支持并发的语言，支持并发意味着多线程，线程的频繁创建在高并发及大数据量是非常消耗资源的，因此java提供了线程池。线程池好处：线程是稀缺资源，如果被无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，合理的使用线程池对线程进行统一分配、调优和监控，有以下好处：降低资源消耗；提高响应速度；提高线程的可管理性。在jdk1.5以前的版本中，线程池的使用是及其简陋的，但是在JDK1.5后，有了很大的改善。JDK1.5之后加入了java.util.concurrent
复制链接

扫一扫