创建线程(异步/多线程)的四种方式-Thread/Runnable/ThreadPoolExecutor/Callable+Spring框架用法

BB-X
已于 2023-08-31 17:54:18 修改
阅读量7.1k
点赞数 2
分类专栏：基础知识文章标签： java
于 2022-09-26 18:33:44 首次发布
本文链接：https://blog.csdn.net/weixin_51091560/article/details/127058532
版权
基础知识专栏收录该内容
14 篇文章 0 订阅
订阅专栏
package com.xch.thread;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.concurrent.*;

/**
 * 创建线程的四种方式：
 * 1、继承Thread类-重写run方法
 * 2、实现Runnable接口-重写run方法
 * 3、创建new ThreadPoolExecutor(...)线程池
 * 4、实现Callable<T>接口-重写call方法
 * 
 * 附加Spring框架用法：
 * 5、使用Spring注解@EnableAsync+@Async
 * 6、使用Spring默认线程池
 * 
 * 其中，
 * 第四种为半异步执行(任务是由子线程执行，但是主线程会阻塞等子线程的结果)
 * 其它为异步执行
 */

//写法一
class Test01_1 extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("创建线程的第一种方法：继承Thread类-重写run方法" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Test01_1());
        thread.start();
    }
}

//写法二
class Test01_2 {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("创建线程的第一种方法：继承Thread类-重写run方法" + Thread.currentThread().getName());
        }).start();
    }
}

/**
 * 写法一
 */
class Test02_1 implements Runnable {
    @Override
    public void run() {
        System.out.println("创建线程的第二种方法：实现Runnable接口-重写run方法" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Test02_1());
        thread.start();
    }
}

/**
 * 写法二
 */
class Test02_2 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("创建线程的第二种方法：实现Runnable接口-重写run方法" + Thread.currentThread().getName());
            }
        }).start();
    }
}

/**
 * 写法一
 */
class Test03_1 {
    public static void main(String[] args) {
        /**
         * corePoolSize/核心池大小：是指初始线程池中的持续活跃线程数
         * maximumPoolSize/最大池大小：是指线程池最大可容纳线程数
         * keepAliveTime/保持活跃时间：是指额外新增线程的空闲存活时间(单位Long)
         * TimeUnit/时间单位：是指上述线程空闲存活时间的时间度量单位(枚举TimeUnit)
         * BlockingQueue<Runnable>/阻塞队列：是指任务超过活跃线程数后进入的等待队列(底层是数组实现)
         * ThreadFactory/线程工厂：是指创建线程的方式(参数可选)
         *      默认是：默认线程工厂Executors.defaultThreadFactory()
         * RejectedExecutionHandler/拒绝执行处理器：是指任务超过线程池最大容量+阻塞队列大小时的拒绝处理机制(参数可选)
         *      默认是：超过则抛出异常机制new ThreadPoolExecutor.AbortPolicy()
         *
         * 线程池执行任务流程：
         *      创建线程池(new ThreadPoolExecutor(...))-run->执行任务(xxx.execute())-run->新建核心线程执行(corePoolSize)
         *      [-overflow->任务分配到阻塞队列(BlockingQueue)-overflow->创建线程直至线程池满(ThreadFactory-maximumPoolSize)
         *      -overflow->执行拒绝策略(RejectedExecutionHandler)-run->线程执行完任务后继续获取阻塞队列中的线程执行
         *      -run->新增的线程超过空闲存活时间后被销毁(keepAliveTime+TimeUnit)]
         *      -run->释放线程池(xxx.shutdown())
         *
         * 线程池的四种拒绝策略：
         * 1、AbortPolicy/抛出策略：抛出拒绝执行异常RejectedExecutionException(默认)
         * 2、CallerRunsPolicy/调用运行策略：继续执行溢出任务
         * 3、DiscardPolicy/丢弃策略：丢弃溢出任务
         * 4、DiscardOldestPolicy/丢弃最老策略：丢弃阻塞队列头的最老任务
         *
         * 池化思想(如银行营业厅)例子：线程池、常量池、数据库连接池
         *
         * 线程池的优点：
         * 1、提高资源利用效率(不用手动创建线程对象、执行任务、释放线程对象)
         * 2、提高线程利用效率(一个线程执行完了任务可以再执行阻塞队列中的任务，而不需要像传统方式一个线程只执行一个任务）
         * 3、提高程序/系统响应速度
         * 4、便于统一管理线程对象
         * 5、可以控制最大并发数
         */
        ExecutorService executorService = new ThreadPoolExecutor(3, 5, 1L, TimeUnit.SECONDS
                , new ArrayBlockingQueue<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        System.out.println("创建线程的第三种方法：创建new ThreadPoolExecutor(...)线程池");
        for (int i = 1; i <= 8; i++) {
            int temp = i;
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "===>执行任务" + temp);
            });
        }
        //调用shutdown方法，线程池执行完当前已submit任务，让该线程池结束
        //(shutdownNow方法，立即让线程池结束，中断当前执行的任务，已submit阻塞任务不再执行)
        executorService.shutdown();
    }
}

/**
 * 写法二
 */
class Test03_2 {
    public static void main(String[] args) {
        //由于Executors创建的线程池，阻塞队列为Integer.MAX_VALUE，容易OOM，所以不建议使用
        //单线程线程池
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
        //缓存线程池(无限动态拓展)
        ExecutorService executorService2 = Executors.newCachedThreadPool();
        //任务夺取线程池(空闲线程可获取其它线程的未执行任务)
        ExecutorService executorService3 = Executors.newWorkStealingPool();
        //固定线程池(自定义大小)
        ExecutorService executorService4 = Executors.newFixedThreadPool(5);
        System.out.println("创建线程的第三种方法：创建new ThreadPoolExecutor(...)线程池");
        for (int i = 1; i <= 8; i++) {
            int temp = i;
            executorService1.execute(() -> System.out.println(Thread.currentThread().getName() + "===>执行任务" + temp));
        }
        //调用shutdown方法，线程池执行完当前已submit任务，让该线程池结束
        //(shutdownNow方法，立即让线程池结束，中断当前执行的任务，已submit阻塞任务不再执行)
        executorService1.shutdown();
        executorService2.shutdown();
        executorService3.shutdown();
        executorService4.shutdown();
    }
}

/**
 * 写法三
 */
class Test03_3 {
    public static void main(String[] args) {
        //由于Executors创建的线程池，阻塞队列为Integer.MAX_VALUE，容易OOM，所以不建议使用
        //单线程线程池
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
        //缓存线程池(无限动态拓展)
        ExecutorService executorService2 = Executors.newCachedThreadPool();
        //任务夺取线程池(空闲线程可获取其它线程的未执行任务)
        ExecutorService executorService3 = Executors.newWorkStealingPool();
        //固定线程池(自定义大小)
        ExecutorService executorService4 = Executors.newFixedThreadPool(5);
        System.out.println("创建线程的第三种方法：创建new ThreadPoolExecutor(...)线程池");
        for (int i = 1; i <= 8; i++) {
            int temp = i;
            executorService2.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "===>执行任务" + temp);
                }
            });
        }
        //调用shutdown方法，线程池执行完当前已submit任务，让该线程池结束
        //(shutdownNow方法，立即让线程池结束，中断当前执行的任务，已submit阻塞任务不再执行)
        executorService1.shutdown();
        executorService2.shutdown();
        executorService3.shutdown();
        executorService4.shutdown();
    }
}

/**
 * 写法一
 */
class Test04_1 implements Callable<String> {
    @Override
    public String call() {
        return "创建线程的第四种方法：实现Callable<T>接口-重写call方法" + Thread.currentThread().getName();
    }

    public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<>(new Test04_1());
        Thread thread = new Thread(futureTask);
        thread.start();
        //主线程会等子线程的结果
        System.out.println(futureTask.get());
    }
}

/**
 * 写法二
 */
class Test04_2 {
    public static void main(String[] args) throws Exception {
        Callable<String> callable = () -> {
            return "创建线程的第四种方法：实现Callable<T>接口-重写call方法" + Thread.currentThread().getName();
        };
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        //主线程会等子线程的结果
        System.out.println(futureTask.get());
    }
}

/**
 * 写法三
 */
class Test04_3 {
    public static void main(String[] args) throws Exception {
        Callable<String> callable = () -> "创建线程的第四种方法：实现Callable<T>接口-重写call方法" + Thread.currentThread().getName();
        //创建线程池执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        //调用submit方法，执行Callable对象
        Future<String> a4Future = executorService.submit(callable);
        //调用shutdown方法，线程池执行完当前已submit任务，让该线程池结束
        executorService.shutdown();
        //主线程会等子线程的结果
        System.out.println(a4Future.get());
    }
}

/**
 * 使用Spring注解@EnableAsync+@Async
 * 1、该异步类被Spring管理(需启动Web容器)
 * 2、该异步类使用@EnableAsync
 * 3、该异步方法使用@Async
 */
@SpringBootTest
class Test05_1 {
    private final Test05_2 test05_2;

    @Autowired
    public Test05_1(Test05_2 test05_2) {
        this.test05_2 = test05_2;
    }

    @Test
    public void test() {
        test05_2.method();
    }
}

@Component
@EnableAsync
class Test05_2 {
    @Async
    public void method() {
        System.out.println("附加Spring框架的第五种方法：使用Spring注解@EnableAsync+@Async" + Thread.currentThread().getName());
    }
}

/**
 * 使用Spring默认线程池
 * 1、需启动Web容器
 */
@SpringBootTest
class Test06_1 {
    private final ThreadPoolTaskExecutor threadPoolTaskExecutor;

    @Autowired
    public Test06_1(ThreadPoolTaskExecutor threadPoolTaskExecutor) {
        this.threadPoolTaskExecutor = threadPoolTaskExecutor;
    }

    @Test
    public void test() {
        threadPoolTaskExecutor.execute(() -> System.out.println("附加Spring框架的第六种方法：使用Spring默认线程池" + Thread.currentThread().getName()));
        //Spring的默认线程池，不用shutdown关闭，会随Spring容器(main主线程)的生命周期
    }
}