Java中创建线程的方式以及线程池创建的方式、推荐使用ThreadPoolExecutor以及示例

左手的ㄟ右手 2023-09-30 22:47 10阅读 0赞

## 场景 ##

Java中创建线程的方式有三种

1、通过继承Thread类来创建线程

定义一个线程类使其继承Thread类，并重写其中的run方法，run方法内部就是线程要完成的任务，

因此run方法也被称为执行体，使用start方法来启动线程。

2、通过实现Runanle接口来创建线程

首先定义Runnable接口，并重写Runnable接口的run方法，run方法的方法体同样是该线程的线程执行体。

3、通过Callable 和 Future来创建线程

Runnable接口执行的是独立的任务，Runnable接口不会产生任何返回值，

如果希望在任务完成之后能够返回一个值的话，可以实现Callable接口。

注：

博客：  
[霸道流氓气质的博客\_CSDN博客-C\#,架构之路,SpringBoot领域博主][CSDN_-C_SpringBoot]

### 实现 ###

### Java创建线程的三种方式 ###

1、通过继承Thread类来创建线程

public class TJavaThread extends Thread{
        static int count;
    
        @Override
        public synchronized void run() {
            for(int i =0;i<10000;i++){
                count++;
            }
        }
    
        public static void main(String[] args) {
            TJavaThread tJavaThread = new TJavaThread();
            tJavaThread.start();
            try {
                //使用线程的join方法，用来等待线程的执行结束，如果不加join方法，它就不会等待tJavaThread的执行完毕。
                tJavaThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(count);
        }
    }

2、通过实现Runanle接口来创建线程

public class TJavaThreadRunable implements Runnable{
    
        static int count;
    
        @Override
        public synchronized void run() {
            for(int i=0;i<10000;i++){
                count++;
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new TJavaThreadRunable());
            thread.start();
            thread.join();
            System.out.println(count);
        }
    }

3、通过Callable 和 Future来创建线程

public class TJavaThreadCallable implements Callable {
    
        static int count;
        public TJavaThreadCallable(int count){
            this.count = count;
        }
    
        @Override
        public Object call(){
            return count;
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            FutureTask<Integer> task = new FutureTask((Callable<Integer>)()->{
                for (int i =0;i<1000;i++){
                    count++;
                }
                return count;
            });
            Thread thread = new Thread(task);
            thread.start();
    
            Integer total = task.get();
            System.out.println(total);
        }
    }

### Java使用线程池来创建线程 ###

Executor虽然不是传统线程创建的方式之一，但是它却成为了创建线程的替代者，使用线程池的好处  
1、利用线程池能够复用线程、控制最大并发数  
2、实现任务线程队列缓存策略和拒绝机制  
3、实现某些与时间相关的功能，如定时执行、周期执行等。  
4、隔离线程环境。比如两个服务在同一台服务器上，分别开启两个线程池，避免各服务线程相互影响。

ExecutorService是Executor的默认实现，也是Executor的扩展接口，

ThreadPoolExecutor类提供了线程池的扩展实现。Executors类为这些Executor提供了方便的工厂方法。

ExecutorService创建线程的几种方式：

1、CacheedThreadPool

创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。

如果现有线程没有可用的，则创建一个新线程并添加到池中。

终止并从缓存中移除那些已有 60 秒钟未被使用的线程。CacheThreadPool会为每一个任务都创建一个线程

private static void CacheedThreadPoolTest() {
            ExecutorService service = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++) {
                //submit()有返回值，而execute()没有
                //submit()可以进行Exception处理
                service.execute(() -> {
                    int count = 0;
                    for (int j = 0; j < 10000; j++) {
                        count++;
                    }
                    System.out.println(count);
                });
            }
            service.shutdown();
        }

2、FixedThreadPool

使你可以使用有限的线程集来启动多线程,

可以一次性的预先执行高昂的线程分配，因此也就可以限制线程的数量。

这样可以节省时间，因为你不必为每个任务都固定的付出创建线程的开销。

private static void FixedThreadPoolTest() {
            ExecutorService service = Executors.newFixedThreadPool(5);
            for (int i = 0; i < 5; i++) {
                int k = i;
                service.execute(() -> {
                    int count = 0;
                    for (int j = 0; j < 10000; j++) {
                        count++;
                    }
                    System.out.println(count);
                    System.out.println(Thread.currentThread().getId() + "--" + k);
                });
            }
            //ExecutorService 对象是使用静态的Executors创建的，这个方法可以确定Executor类型。对shutdown的调用可以防止新任务提交给ExecutorService,
            //这个线程在Executor中所有任务完成后退出、
            service.shutdown();
        }

3、SingleThreadExecutor

就是线程数量为1的FixedThreadPool,如果向SingleThreadPool一次性提交了多个任务，

那么这些任务将会排队。每个任务都会在下一个任务开始前结束，所有的任务都将使用相同的线程。

SingleThreadPool会序列化所有提交给他的任务，并会维护它自己的悬挂队列。

从输出结果来看，任务都是挨着进行的。为任务分配五个线程，但是这五个线程不像上面有换进换出的效果，

它每次都会先执行完自己的那个线程，然后余下的线程继续走完这条线程的执行路径。

可以使用SingleThreadExecutor来确保任意时刻都只有唯一一个任务在运行。

private static void SingleThreadExecutorTest() {
            ExecutorService service = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 5; i++) {
                int k = i;
                service.execute(() -> {
                    int count = 0;
                    for (int j = 0; j < 10000; j++) {
                        count++;
                    }
                    System.out.println(count);
                    System.out.println(Thread.currentThread().getId() + "--" + k);
                });
            }
            //ExecutorService 对象是使用静态的Executors创建的，这个方法可以确定Executor类型。对shutdown的调用可以防止新任务提交给ExecutorService,
            //这个线程在Executor中所有任务完成后退出、
            service.shutdown();
        }

4、ScheduledThreadPool

常用于需要延迟执行或周期循环执行任务的场景

schedule()方法可以用来延迟任务的执行

运行下面任务，则先输出时间，延迟2秒后才执行

private static void ScheduledThreadPoolTestSchedule() {
            System.out.println("当前时间:" + System.currentTimeMillis());
            ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
            service.schedule(
                    () ->
                    System.out.println("开始执行:" + System.currentTimeMillis()), 2, TimeUnit.SECONDS);
            service.shutdown();
        }

scheduleAtFixedRate()方法 固定频率执行方法

private static void ScheduledThreadPoolTestFixedRate(){
            System.out.println("当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(5);
            executor.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            },2,1,TimeUnit.SECONDS);
        }

scheduleWithFixedDelay 固定的间隔时间执行任务

private static void ScheduledThreadPoolTestFixedDelay(){
            System.out.println("当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(5);
            executor.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            },2,1,TimeUnit.SECONDS);
        }

scheduleAtFixedRate与scheduleWithFixedDelay区别？

scheduleAtFixedRate的下一次执行时间是上一次执行时间＋间隔时间

scheduleWithFixedDelay下一次执行时间是上一次执行时间结束时系统时间+间隔时间

scheduleAtFixedRate执行结果

![deff573b4faa48958ea1cdc440225c8f.jpeg][]

scheduleWithFixedDelay执行结果

![8bf334a45d624e68be83e3b7eb48273c.jpeg][]

5、newSingleThreadScheduledExecutor：创建⼀个单线程的可以执⾏延迟任务的线程池；

private static void SingleThreadScheduleTest(){
            System.out.println("当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
            ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
            executorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(System.currentTimeMillis()));
                }
            },2,1,TimeUnit.SECONDS);
        }

6、newWorkStealingPool：创建⼀个抢占式执⾏的线程池（任务执⾏顺序不确定）

又称任务窃取线程池，可以传入线程的数量，不传入，则默认使用当前计算机中可用的cpu数量，

实际的线程数可能会动态增长和收缩，不能保证提交任务的执行顺序。

以下为设置线程数为4

private static void WorkStealingPoolTest(){
            ExecutorService executorService = Executors.newWorkStealingPool(4);
            for (int i =0;i<10;i++){
                executorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        String name = Thread.currentThread().getName();
                        System.out.println(name+"开始执行");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(name+"执行结束");
                    }
                });
            }
            System.out.println("cpu核心数:"+ Runtime.getRuntime().availableProcessors());
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

运行效果

![b4ae7b865011459688355d46e8f301dc.png][]

这里的cpu核心数为8，如果不设置线程数则直接

ExecutorService executorService = Executors.newWorkStealingPool();

此时执行结果

![4f7b4f4a92f04754aa897eac4c78e7ef.png][]

### 线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式 ###

《阿里巴巴JAVA开发手册》有这样一条强制规定：

线程池不允许使用Executors去创建，而应该通过ThreadPoolExecutor方式，这样处理方式更加明确线程池运行规则，

规避资源耗尽风险。

说明： Executors 返回的线程池对象的弊端如下：  
(1） FixedThreadPool 和 SingleThreadPool ：  
允许的请求队列的长度可能会堆积大量的请求，从而导致 OOM。  
(2） CachedThreadPool ：  
允许的创建线程数量为 Integer.MAX\_VALUE，可能会创建大量的线程，从而导致 OOM。

#### ThreadPoolExecutor参数说明 ####

corePoolSize - 线程池核心线程数量  
maximumPoolSize - 线程池最大数量  
keepAliveTime - 空闲线程存活时间  
unit - 时间单位  
workQuene - 线程池中所使用的缓冲队列  
handler - 线程池对拒绝任务的处理策略

#### ThreadPoolExecutor执行流程 ####

![41d86631055c4cae9566438d57dbbdf0.png][]

示例代码

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3), new ThreadPoolExecutor.AbortPolicy());
            for(int i =1;i<=7;i++){
                String task = "task:"+i;
                threadPoolExecutor.execute(new ThreadPoolTask(task));
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

任务具体实现类

static class ThreadPoolTask implements Runnable{
    
            private String taskName;
    
            ThreadPoolTask(String task){
                this.taskName = task;
            }
    
            @Override
            public void run() {
                System.out.println("启动:"+taskName);
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

这里假设每个任务需要执行10秒，每隔0.5秒执行一个任务。

当循环数为7，即不大于最大线程数+队列大小时，执行结果如下  
启动:task:1  
启动:task:2  
启动:task:6  
启动:task:7  
启动:task:3  
启动:task:4  
启动:task:5

![eb69ec6e5d8e478eb38688cdb348bb8f.png][]

执行结果分析:

提交1、2两个任务，判断小于corePoolSize,会为每一个任务创建一个线程

提交3、4、5三个任务时，判断正在执行的任务数量为2，且每个任务执行时间为10s,所以会将这三个放入到workQueue中等待执行

提交6、7两个任务时，因为workQuene队列的大小为3，此时workQueue队列中存储的任务数量满了，

会判断当前线程池中正在执行的任务是否小于maximumPoolSize,这里是4，

如果小于4则创建新的线程来执行任务6和7，此时7个任务都提交完毕，那么等待任务3、4、5会在前面每个10s的任务执行完之后执行。

当修改循环数为10

启动:task:1  
启动:task:2  
启动:task:6  
启动:task:7  
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task [com.ruoyi.demo.thread.threadpool.ThreadPool$ThreadPoolTask@deb6432][com.ruoyi.demo.thread.threadpool.ThreadPool_ThreadPoolTask_deb6432] rejected from [java.util.concurrent.ThreadPoolExecutor@28ba21f3\[Running][java.util.concurrent.ThreadPoolExecutor_28ba21f3_Running], pool size = 4, active threads = 4, queued tasks = 3, completed tasks = 0\]  
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)  
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)  
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)  
at com.ruoyi.demo.thread.threadpool.ThreadPool.ThreadPoolExecutorTest(ThreadPool.java:230)  
at com.ruoyi.demo.thread.threadpool.ThreadPool.main(ThreadPool.java:280)  
启动:task:3  
启动:task:4  
启动:task:5

![448c8108991944be9daabed0eb494f0e.png][]

执行结果分析，当执行第8个任务时，判断执行线程总数大于最大线程数+队列大小，直接执行拒绝策略，同理任务9和10也是如此。  
这里的拒绝策略是AbortPolicy

#### 拒绝策略 ####

1、AbortPolicy - 丢弃任务并抛出RejectedExecutionException异常

2、CallerRunsPolicy - 将被拒绝的任务添加到线程池正在运行的线程中去执行

将上面修改之后的执行结果

//启动:task:1  
//启动:task:2  
//启动:task:6  
//启动:task:7  
//启动:task:8  
//启动:task:3  
//启动:task:4  
//启动:task:5  
//启动:task:9  
//启动:task:10

3、DiscardPolicy - 丢弃任务，但是不抛出异常  
//此时执行结果如下  
//启动:task:1  
//启动:task:2  
//启动:task:6  
//启动:task:7  
//启动:task:3  
//启动:task:4  
//启动:task:5

4、DiscardOldestPolicy - 丢弃队列最前面的任务，然后重新尝试执行任务  
//此时执行结果如下  
//启动:task:1  
//启动:task:2  
//启动:task:6  
//启动:task:7  
//启动:task:8  
//启动:task:9  
//启动:task:10

[CSDN_-C_SpringBoot]: https://blog.csdn.net/badao_liumang_qizhi
[deff573b4faa48958ea1cdc440225c8f.jpeg]: https://img-blog.csdnimg.cn/deff573b4faa48958ea1cdc440225c8f.jpeg
[8bf334a45d624e68be83e3b7eb48273c.jpeg]: https://img-blog.csdnimg.cn/8bf334a45d624e68be83e3b7eb48273c.jpeg
[b4ae7b865011459688355d46e8f301dc.png]: https://img-blog.csdnimg.cn/b4ae7b865011459688355d46e8f301dc.png
[4f7b4f4a92f04754aa897eac4c78e7ef.png]: https://img-blog.csdnimg.cn/4f7b4f4a92f04754aa897eac4c78e7ef.png
[41d86631055c4cae9566438d57dbbdf0.png]: https://img-blog.csdnimg.cn/41d86631055c4cae9566438d57dbbdf0.png
[eb69ec6e5d8e478eb38688cdb348bb8f.png]: https://img-blog.csdnimg.cn/eb69ec6e5d8e478eb38688cdb348bb8f.png
[com.ruoyi.demo.thread.threadpool.ThreadPool_ThreadPoolTask_deb6432]: mailto:com.ruoyi.demo.thread.threadpool.ThreadPool$ThreadPoolTask@deb6432
[java.util.concurrent.ThreadPoolExecutor_28ba21f3_Running]: mailto:java.util.concurrent.ThreadPoolExecutor@28ba21f3%5BRunning
[448c8108991944be9daabed0eb494f0e.png]: https://img-blog.csdnimg.cn/448c8108991944be9daabed0eb494f0e.png