• Java创建多线程的四种方式

    爱人如己。

    多线程

            多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。

            多线程是并行化的一种形式，或者是拆分工作以便同时进行处理。线程化的程序将工作拆分到多个软件线程，而不是将大量工作交给单个内核。这些线程由不同的 CPU 内核并行处理，以节省时间。

            进程是程序的一次执行，进程至少包含一个线程，也就是主线程main_thread，同一个进程内的所有线程共享这个进程的所有资源。

            资源包括：线程可以操作进程内存空间中的全局变量、静态变量等。 线程可以共享进程打开的文件描述符，这意味着多个线程可以同时对同一个文件进行读写操作，不同线程之间的文件操作是相互可见的。

            正是由于多个线程可以并行（具有多核cpu）共享进程的资源，所以会导致共享数据的一致性等问题，所以要使用互斥锁、信号量、条件变量等同步机制保证共享数据的一致性。

    线程的生命周期

    新建、就绪、运行、阻塞、死亡

    Java使用多线程的方式

    1、继承Thread类

    1. package com.lin.java;
    2.  
    3. /**
    4.  * 线程的创建方式一：继承Thread类
    5.  *      1.创建继承于Thread类的子类
    6.  *      2.重写Thread类中的run（）方法，用于描述线程要执行的操作
    7.  *      3.创建Thread类的子类的对象
    8.  *      4.通过对象调用start()方法
    9.  * 
    10.  * @author shkstart
    11.  * @create 2021-08-12 10:47
    12.  */
    13. public class ThreadTest1 {
    14.     public static void main(String[] args) {// 主线程
    15.         // 3.创建Thread类的子类的对象
    16.         MyThread t1 = new MyThread();
    17.         t1.setName("线程1");// 给线程起名字
    18.  
    19.         // 4.通过对象调用start()方法
    20.         // start()方法的作用：①启动当前线程 ②并执行当前线程对象的run()方法
    21.         // 注意：一个线程对象只能调用一次start()方法
    22.         t1.start();// 主线程执行到这，开始执行另一个线程
    23.  
    24.         // 在创建一个进程：输出100以内的偶数
    25.         MyThread t2 = new MyThread();
    26.         t2.setName("线程2");
    27.         t2.start();// 此时相当于三个线程同时执行
    28.  
    29.         Thread.currentThread().setName("主线程");
    30.         for (int i = 0;i < 100;i++){// 主线程和另外两个线程t1 t2同时的执行
    31.             if (i % 2 == 0){
    32.             System.out.println(Thread.currentThread().getName() + " " + i);
    33.             }
    34.         }
    35.     }
    36. }
    37.  
    38. /*
    39.    线程的创建方式一：继承Thread类
    41.    创建一个线程用来输出100以内的偶数
    42.  */
    43.  
    44. // 1.创建继承于Thread类的子类,说明此类是线程类
    45. class MyThread extends Thread{
    46.  
    47.     // 2.重写Thread类中的run（）方法，用于描述线程要执行的操作
    48.     @Override
    49.     public void run() {
    50.         // 线程要执行的操作：用来输出100以内的偶数
    51.         for (int i = 0;i < 100;i++){
    52.             if (i % 2 == 0){
    53.             System.out.println(Thread.currentThread().getName() +  " " + i);
    54.             }
    55.         }
    56.     }
    57. }

    2、实现Runnable接口

    1. package com.lin.java;
    2.  
    3. /**
    4.  * 创建线程的方式二：实现Runnable接口
    5.  * 1.创建Runnable接口的实现类
    6.  * 2.实现Runnable接口中的run()方法，将线程要执行的操作写在此方法中
    7.  * 3.创建Runnable接口的实现类的对象
    8.  * 4.将Runnable接口的实现类的对象作为参数传递给Thread的构造器，创建Thread对象
    9.  * 5.通过Thread类的对象调用start()方法
    10.  *
    11.  *
    12.  * 比较创建线程的两种方式。
    13.  *  * 开发中：优先选择：实现Runnable接口的方式
    14.  *  * 原因：1. 实现的方式没有类的单继承性的局限性
    15.  *  *      2. 实现的方式更适合来处理多个线程有共享数据的情况。（原因见WindowTest1.java)
    16.  *  *
    17.  *  * 联系：public class Thread implements Runnable
    18.  *  * 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
    19.  *  *
    20.  *
    21.  * @author shkstart
    22.  * @create 2021-08-15 11:23
    23.  */
    24. public class ThreadTest2 {
    25.     public static void main(String[] args) {
    26.         // 3.创建Runnable接口的实现类的对象
    27.         NumThread2 numThread2 = new NumThread2();
    28.  
    29.         // 4.将Runnable接口的实现类的对象作为参数传递给Thread的构造器，创建Thread对象
    30.         // 此步其实是创建一个线程，但构造器需要Runnable接口对象
    31.         Thread thread = new Thread(numThread2);
    32.  
    33.         thread.setName("线程1");
    34.         // 5.通过Thread类的对象调用start()方法
    35.         thread.start();
    36.  
    37.         // 再创建一个线程
    38.         Thread thread1 = new Thread(numThread2);
    39.         thread1.setName("线程2");
    40.         thread1.start();
    41.     }
    42. }
    43.  
    44.  
    45. // 1.创建Runnable接口的实现类
    46. class NumThread2 implements Runnable{
    47.  
    48.     // 2.实现Runnable接口中的run()方法，将线程要执行的操作写在此方法中
    49.     @Override
    50.     public void run() {
    51.         for (int i = 0; i < 100; i++) {
    52.             if (i % 2 == 0){
    53.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    54.             }
    55.         }
    56.     }
    57. }

    3、实现Callable接口

    1. package com.lin.java;
    2.  
    3. import java.util.concurrent.Callable;
    4. import java.util.concurrent.ExecutionException;
    5. import java.util.concurrent.FutureTask;
    6.  
    7. /**
    8.  * 创建线程的方式三：实现Callable接口 --- JDK 5.0新增
    9.  * 说明：1.需要借助FutureTask类，比如可以获取call()方法中返回值 ---FutureTask类中的get()
    10.  *      2.FutureTask类实现了Runnable 和 Callable 接口
    11.  *      3.FutureTask类即可以做为Runnable被线程执行，又可以做为Future获取call方法中的返回值
    12.  *
    13.  *
    14.  *  1.创建Callable接口的实现类
    15.  *  2.实现Callable接口中的call()方法，将线程要执行的操作写在此方法中
    16.  *  3.创建创建Callable接口的实现类的对象
    17.  *  4.将Callable接口的实现类的对象作为参数传递给FutureTask的构造器，并创建FutureTask对象
    18.  *  5.将FutureTask对象作为参数传递给Thread类的构造器，创建Thread对象，并调用start()方法
    19.  *
    20.  *
    21.  *
    22.  * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
    23.  * 优点：1.线程有返回值   call()
    24.  *      2.可以抛出异常，在外部调用可以捕获异常   call()
    25.  *      3.Callable是支持泛型的
    26.  *
    27.  * @author shkstart
    28.  * @create 2021-08-15 9:16
    29.  */
    30. public class ThreadTest3 {
    31.     public static void main(String[] args) {
    32.         Thread.currentThread().setName("主线程");
    33.  
    34.         // 3.创建创建Callable接口的实现类的对象
    35.         MyTread3 t = new MyTread3();
    36.  
    37.  
    38.         // 4.将Callable接口的实现类的对象作为参数传递给FutureTask的构造器，并创建FutureTask对象
    39.         FutureTask futureTask = new FutureTask(t);// 创建FutureTask对象需要Callable接口对象作为构造器参数
    40.  
    41.         // 5.将FutureTask对象作为参数传递给Thread类的构造器，创建Thread对象，并调用start()方法
    42.         Thread thread = new Thread(futureTask);// 创建线程Thread对象需要Runnable接口对象作为构造器参数，此时FutureTask类的对象做为Runnable被线程执行
    43.         thread.setName("分线程");
    44.         thread.start();// 启动线程
    45.  
    46.         // 6.获取Callable中call方法的返回值
    47.         try {
    48.             // futureTask.get()用于获取线程方法call()的返回值
    49.             System.out.println("总和为：" + futureTask.get());// 此时FutureTask作为Future获取call方法中的返回值
    50.         } catch (InterruptedException e) {
    51.             System.out.println(e.getMessage());
    52.         } catch (ExecutionException e) {
    53.             System.out.println(e.getMessage());
    54.         }
    55.  
    56.         // 错误的，仍然是主线的做的，并没有启动线程做
    57. //        try {
    58. //            t.call();
    59. //        } catch (Exception e) {
    60. //            e.printStackTrace();
    61. //        }
    62.     }
    63. }
    64.  
    65. // 1.创建Callable接口的实现类
    66. class MyTread3 implements Callable{
    67.  
    68.     // 2.实现Callable接口中的call()方法，将线程要执行的操作写在此方法中
    69.     @Override
    70.     public Object call() throws Exception {
    71.         int sum = 0;
    72.         int i = 1;
    73.         for (; i <= 100; i++) {
    74.             System.out.println(Thread.currentThread().getName() + i);
    75.             sum += i;
    76.         }
    77.  
    78. //        if (i == 101){
    79. //            // 手动抛出一个异常对象
    80. //            throw new Exception("我是call方法中的异常");
    81. //        }
    82.         return sum;
    83.     }
    84. }

    4、使用线程池

    （1）为什么要使用线程池？

    方便管理和调控，因为线程池中的线程都是提前创建好的，可以节省创建线程的时间。重复利用线程池中的线程避免或者说降低了重复创建线程和的消耗。

    创建和销毁线程的消耗所在

    创建线程：

            当创建一个线程时，操作系统需要为线程分配一定的资源，包括线程栈空间、线程标识符等。
            在 Java 中，创建线程需要分配内存空间来存储线程的执行栈、线程状态等信息。


    销毁线程（一般是在线程的run方法执行完毕或者被中断，线程就会自动销毁掉）：

            当线程执行完成或者被中断时，操作系统需要释放线程所占用的资源。
            在 Java 中，线程销毁时会释放线程对象所占用的内存空间，包括线程栈空间等资源。


    尽管线程的创建和销毁过程很快，但是它们仍然需要消耗一定的系统资源。因此，在设计和开发多线程应用程序时，需要合理地管理线程的生命周期，避免不必要的线程创建和销毁，以减少系统资源的消耗。

    线程池工作原理：

            例如线程池中最多可以允许创建三个工作线程, 也叫核心线程, 前面三个任务来的时候会给前面三个任务单独创建三个线程; 但是后面任务再来的时候, 因为创建的工作线程已达到最大数, 那么后面的任务就会进入任务队列中排队等待; 等前面的任务执行完成, 有空闲的线程的时候使用空闲的线程依次执行任务队列中的任务。

    参数名作用
    corePoolSize核心线程数量
    maximumPoolSize最大线程池数量
    keepAliveTime线程池中超过corePoolSize数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true)使得核心线程有效时间
    TimeUnitkeepAliveTime时间单位
    workQueue阻塞任务队列
    threadFactory新建线程工厂
    RejectedExecutionHandler当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理

    1. // Java线程池类
    2. // 一、ThreadPoolExecutor
    3. public ThreadPoolExecutor(int corePoolSize,
    4.                           int maximumPoolSize,
    5.                           long keepAliveTime,
    6.                           TimeUnit unit,
    7.                           BlockingQueue workQueue,
    8.                           ThreadFactory threadFactory,
    9.                           RejectedExecutionHandler handler) {}
    10.  
    11. 1、corePoolSize 线程池中的核心线程数
    12.     当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize, 即使有其他空闲线程能够执行新来的任务, 也会继续创建线程；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。核心线程即使执行完任务也不会停止，会继续存在等待新任务。
    13.     设置规则：
    14.     (1)CPU密集型(CPU密集型也叫计算密集型，指的是运算较多，cpu占用高，读/写I/O(硬盘/内存)较少)：corePoolSize = CPU核数 + 1
    15.     (2)IO密集型（与cpu密集型相反，系统运作，大部分的状况是CPU在等I/O (硬盘/内存) 的读/写操作，此时CPU Loading并不高。）：corePoolSize = CPU核数 * 2
    16.  
    17. 2、workQueue 用来暂时保存任务的工作队列:  
    18. (1)ArrayBlockingQueue: 基于数组结构的有界阻塞队列，按FIFO先进先出排序任务；
    19.  
    20. (2)LinkedBlockingQueue: 基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQueue；
    21.  
    22. (3)SynchronousQueue: 一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue；
    23.  
    24. (4)PriorityBlockingQueue: 具有优先级的无界阻塞队列；
    25.  
    26. LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(), take()任务的时均需要加锁，SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().
    27.  
    28. 3、maximumPoolSize 线程池中允许的最大线程数，maximumPoolSize - corePoolSize就是非核心线程
    29.     最大线程数，默认为Integer.MAX_VALUE，一般设置为和核心线程数一样
    30.     
    31. 4、keepAliveTime 空闲线程的存活时间，非核心线程空闲超过这个时间则销毁
    32.     	
    33. 5、unit keepAliveTime的单位
    34.     
    35. 6、threadFactory 创建线程的工厂，通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名。默认为DefaultThreadFactory
    36.  
    37. 7、handler 拒绝策略，当核心线程数满了，工作队列也满了，线程数达到了线程池允许的最大线程数时，继续提交任务的策略：
    38.     AbortPolicy: 直接抛出异常，默认策略；
    39.     CallerRunsPolicy: 用调用者所在的线程来执行任务；
    40.     DiscardOldestPolicy: 丢弃工作队列中靠最前的任务，并执行当前任务
    41.     DiscardPolicy: 直接丢弃任务；
    42.  
    43.     
    44. // 任务执行
    45. ThreadPoolExecutor有两种提交任务执行的方式：ThreadPoolExecutor.submit()有返回值方便异常处理 和 execute()没有返回值
    46.     
    47. // submit和execute提交任务执行后:
    48. 1、当线程池中的线程数小于corePoolSize时，新提交任务将创建一个新线程去执行任务，即使此时线程池中存在空闲线程。
    49. 2、当线程池中的线程数达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
    50. 3、如果workQueue已满且线程数
    51. 4、如果workQueue已满且线程数=maximumPoolSize，则执行拒绝策略
    52.         
    53. // 二、ThreadPoolTaskExecutor
    54. /**
    55.  * 1、ThreadPoolTaskExecutor
    56.  * 对ThreadPoolExecutor的进一步封装，实际应用中一般使用ThreadPoolTaskExecutor而不是 ThreadPoolExecutor。
    57.  * 使用ThreadPoolExecutor创建线程池需要指定很多参数，ThreadPoolTaskExecutor只有一个无参构造函数，后续可以通过set设置更灵活。
    58.  *
    59.  * 使用ThreadPoolTaskExecutor无需设置阻塞队列类型，只需要按需设置队列大小即可。ThreadPoolTaskExecutor底层使用的队列为：
    60.  * 队列容量大于0则使用 LinkedBlockingQueue队列；否则使用 SynchronousQueue队列；
    61.  *
    62.  * 2、使用@Bean方式注入，保证线程池对象只创建一次
    63.  * @return
    64.  */
    65. @Bean(name = "threadPoolTaskExecutor")
    66. public ThreadPoolTaskExecutor threadPoolTaskExecutor()
    67. {
    68.     ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    69.     executor.setMaxPoolSize(maxPoolSize);
    70.     executor.setCorePoolSize(corePoolSize);
    71.     executor.setQueueCapacity(queueCapacity);
    72.     executor.setKeepAliveSeconds(keepAliveSeconds);
    73.     // 线程池对拒绝任务(无线程可用)的处理策略
    74.     executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    75.     return executor;
    76. }
    77.  
    78. // 三、ScheduledThreadPoolExecutor
    79. /**
    80.  * 执行周期性或定时任务
    81.  *
    82.  * ScheduledThreadPoolExecutor
    83.  * 1、ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用于在给定的延迟之后运行任务，或者定期执行任务。
    84.  * 像其他线程池，提交了任务就会立马执行。
    85.  * ScheduledThreadPoolExecutor的功能与Timer类似，但 ScheduledThreadPoolExecutor功能更强大、更灵活。
    86.  * Timer对应的是单个后台线程，而 ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。
    87.  */
    88. https://blog.csdn.net/qq_43410878/article/details/123732981
    1. package com.lin.java;
    2.  
    3. import java.util.concurrent.*;
    4.  
    5. /**
    6.  * 创建线程的方式四：使用线程池二
    7.  * 直接创建ThreadPoolExecutor对象，并指定参数，推荐使用
    8.  *
    9.  * execute()或submit()方法后：
    10.  * 优先使用核心线程池中的线程去执行任务。当阻塞任务队列满了且核心线程池中没有空闲线程才使用非核心线程池中的线程。
    11.  * 1.当线程池中的线程数小于corePoolSize时，新提交任务将创建一个新线程去执行任务，即使此时线程池中存在空闲线程。
    12.  * 2.当线程池中的线程数达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
    13.  * 3.当workQueue已满，且maximumPoolSize>corePoolSize时，则在非核心线程池中创建新线程执行新任务
    14.  * 4.当提交任务数超过maximumPoolSize时，就是创建的线程数且不是空闲（在执行任务）超过了最多线程数，新提交任务由RejectedExecutionHandler处理
    15.  *
    16.  * 5.当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
    17.  * 6.当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
    18.  *
    19.  * 这个线程创建了，执行完任务后，也不会立即关闭，而是等待cpu调用继续执行任务，所以可以节省创建和销毁线程的时间。
    20.  * 当任务到达时，任务可以不需要等到线程创建就能立即执行。
    21.  *
    22.  * @author shkstart
    23.  * @create 2022-05-21 17:01
    24.  */
    25. public class ThreadTest5 {
    26.     public static void main(String[] args) {
    27.         // 使用给定的参数和默认的线程工厂以及默认的拒绝策略创建一个线程池
    28.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
    29.  
    30.         threadPoolExecutor.execute(new NumThreadNew());// 提交任务给线程池处理,这个是处理没有返回值的任务
    31.  
    32.         // 有返回值
    33.         Future result = threadPoolExecutor.submit(new NumSumNew());// 和execute区别就是提交的任务是有返回值且可以捕获异常的
    34.         try {
    35.             Object o = result.get();
    36.             System.out.println("线程执行的返回值" + o);
    37.         } catch (InterruptedException e) {
    38.             e.printStackTrace();
    39.         } catch (ExecutionException e) {
    40.             e.printStackTrace();
    41.         }
    42.         System.out.println("线程池中的线程数量=" + threadPoolExecutor.getPoolSize());
    43.     }
    44.  
    45. }
    46.  
    47. // 输出100内的偶数的线程
    48. class NumThreadNew implements Runnable{
    49.  
    50.     @Override
    51.     public void run() {
    52.         for (int i = 0; i < 100; i++) {
    53.             if (i % 2 == 0){
    54.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    55.             }
    56.         }
    57.     }
    58. }
    59.  
    60. // 输出100内的奇数的线程
    61. class NumThread1New implements Runnable{
    62.  
    63.     @Override
    64.     public void run() {
    65.         for (int i = 0; i < 100; i++) {
    66.             if (i % 2 == 0){
    67.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    68.             }
    69.         }
    70.     }
    71. }
    72.  
    73. // 输出10以内数字以及计算10以内数字和的线程
    74. class NumSumNew implements Callable {
    75.  
    76.     @Override
    77.     public Object call() throws Exception {
    78.         int sum = 0;
    79.         for (int i = 0; i < 10; i++) {
    80.             System.out.println(Thread.currentThread().getName() + ":" + i);
    81.             sum += i;
    82.         }
    83.  
    84.         return sum;
    85.     }
    86. }

    1. package com.lin.java;
    2.  
    3. import java.util.concurrent.Callable;
    4. import java.util.concurrent.ExecutorService;
    5. import java.util.concurrent.Executors;
    6. import java.util.concurrent.ThreadPoolExecutor;
    7.  
    8. /**
    9.  * 创建线程的方式四：使用线程池一
    10.  * 使用Executors工具类，这种不推荐用，具体原因百度。
    11.  *
    12.  * 好处：
    13.  *  * 1.提高响应速度（减少了创建新线程的时间）
    14.  *  * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    15.  *  * 3.便于线程管理
    16.  *  *      corePoolSize：核心线程数
    17.  *  *      maximumPoolSize：最大线程数
    18.  *  *      keepAliveTime：线程没有任务时最多保持多长时间后会终止
    19.  *  *
    20.  *  *
    21.  *  * 面试题：创建多线程有几种方式？四种！
    22.  *
    23.  * @author shkstart
    24.  * @create 2021-08-15 10:51
    25.  */
    26. public class ThreadTest4 {
    27.     public static void main(String[] args) {
    28.         //1. 提供指定线程数量的线程池--service、service1
    29.         ExecutorService service = Executors.newFixedThreadPool(10);// 这个返回值是ThreadPoolExecutor对象
    30.         ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
    31.  
    32.         // 设置线程池的属性
    33. //        service1.setCorePoolSize(15);
    34.  
    35.         //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
    36.         // 参数是指定要完成什么操作的线程对象
    37.         service1.execute(new NumThread());// 执行任务,适用于实现Runnable，无返回值
    38.         service1.execute(new NumThread1());
    39.         // service1.submit();// 适合使用于Callable,有返回值
    40.  
    41.         System.out.println("线程池中线程的数量" + service1.getPoolSize());
    42.  
    43.         // 3.关闭连接池
    44.         service1.shutdown();
    45.  
    46.     }
    47. }
    48.  
    49. // 输出100内的偶数的线程
    50. class NumThread implements Runnable{
    51.  
    52.     @Override
    53.     public void run() {
    54.         for (int i = 0; i < 100; i++) {
    55.             if (i % 2 == 0){
    56.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    57.             }
    58.         }
    59.     }
    60. }
    61.  
    62. // 输出100内的奇数的线程
    63. class NumThread1 implements Runnable{
    64.  
    65.     @Override
    66.     public void run() {
    67.         for (int i = 0; i < 100; i++) {
    68.             if (i % 2 == 0){
    69.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    70.             }
    71.         }
    72.     }
    73. }
    74.  
    75. // 输出10以内数字以及计算10以内数字和的线程
    76. class NumSum implements Callable{
    77.  
    78.     @Override
    79.     public Object call() throws Exception {
    80.         int sum = 0;
    81.         for (int i = 0; i < 10; i++) {
    82.             System.out.println(Thread.currentThread().getName() + ":" + i);
    83.             sum += i;
    84.         }
    85.  
    86.         return sum;
    87.     }
    88. }

    CompletableFuture-异步任务编排

    上面所使用的线程技术，如果想要控制两个异步任务之间的先后性，是比较麻烦的。

    而CompletableFuture就是帮你处理这些任务之间的逻辑关系，CompletableFuture提供了很多编排任务的API，编排好任务的执行方式后，任务会按照规划好的方式一步一步执行，不需要让业务线程去频繁的等待。

    总之，CompletableFuture类使得并发任务的处理变得简单而高效，通过简洁的API，开发者能轻松创建、组合和链式调用异步操作，无需关心底层线程管理，这不仅提升了程序的响应速度，还优化了资源利用率，让复杂的并发逻辑变得易于掌控。

    参考连接：

    CompletableFuture使用详解（超详细）-CSDN博客

    第25课：CompletableFuture - 知乎 (zhihu.com)

    Java并发基础：CompletableFuture全面解析 (baidu.com)

  • 相关阅读:
    WOT全球技术创新大会2022：腾讯云数据库专场 + 云原生解决方案专场
    自定义事件
    Undefined和Null的区别
    Pytorch 下 TensorboardX 使用
    React之路由
    用Blender制作YOLO目标检测器训练数据
    VMware虚拟机+Centos7 配置静态，动态IP
    【超好懂的比赛题解】第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（济南）
    Mysql批量插入数据时如何解决重复问题
    基于Echarts实现可视化数据大屏机械设备监测大数据统计平台HTML页面
  • 原文地址：https://blog.csdn.net/weixin_52938172/article/details/126957977