多线程编程之——终止(打断)正在执行中的线程

多线程编程之——终止(打断)正在执行中的线程

  • ps:文字有点多,想看结果的,直接跳转:《二》

一、基础知识

1、我们基于spring开发,把线程都交给spring

  • 把线程交给spring管理好不好?

将线程交给Spring管理是一个常见的做法,特别是在基于Spring的应用程序中。通过将线程纳入Spring的管理范围,你可以利用Spring的依赖注入和生命周期管理功能,更好地控制线程的生命周期和资源。这样做也有助于避免手动管理线程带来的潜在问题,比如线程泄露和资源管理不当。但是需要注意的是,要确保在使用Spring管理线程时,遵循最佳实践,避免出现死锁和性能问题。

还有个好处:可以把spring的bean注入到线程中,然后直接使用。(如注入service完成查询数据)

如果把线程交给spring管理,注入线程的地方全是单例,如果要使用这个线程来完成两个不同的任务,需要把单例变成多例模式,spring多例模式见:SpringBoot实现多例模式

  • 一个线程默认当做执行一个任务的最小单元

所以,当你需要执行一个任务的时候,应该把参数封装到线程中,然后在线程中去执行你的任务(方法)

2、启动Thread线程是调用start还是run?

在Java中,启动一个Thread线程应该调用start方法而不是run方法。调用start方法会使Thread进入就绪状态,并让系统调度器来调用run方法。直接调用run方法只会在当前线程中执行run方法的代码,而不会创建新的线程。因此,正确的做法是调用start方法来启动一个新的线程。

3、打断执行中的线程

  • 如果我new了一个Thread线程,它一直在执行中(无限阻塞),我后面调用了interrupt打断线程,这个Thread线程会一直阻塞还是结束任务?

如果你在一个线程对象上调用interrupt方法,会设置线程的中断状态,并且如果线程正在阻塞中(比如在sleep、wait、join等方法中),它会抛出InterruptedException并清除中断状态。但如果线程正在执行普通的任务,它不会自动停止,而是需要在任务中检查中断状态并做出相应的处理。因此,你需要在任务中定期检查线程的中断状态,并在适当的时候结束任务。

  • 我调用interrupt的线程,如果一直处于睡眠中,jvm会自动回收吗?

当你调用一个处于睡眠状态的线程的interrupt方法时,它会抛出InterruptedException并清除中断状态,但并不会导致线程被自动回收。处于睡眠状态的线程会继续睡眠直到其睡眠时间结束或者被唤醒。如果你希望中断一个处于睡眠状态的线程并结束它的任务,你需要在任务中捕获InterruptedException并做出相应的处理。

  • 捕获InterruptedException并在捕获到异常时结束任务或者进行清理工作。示例:
public class MyTask implements Runnable {
    public void run() {
        try {
            // 在这里调用sleep方法使线程进入睡眠状态(模仿无限阻塞)
            Thread.sleep(100000);
        } catch (InterruptedException e) {
            // 捕获InterruptedException并做出相应的处理
            // 可以结束任务或者进行清理工作
            Thread.currentThread().interrupt(); // 重新设置中断状态
            return; // 结束任务
        }
        // 其他任务逻辑
    }
}

在上面的示例中,当线程处于睡眠状态时,如果外部调用了interrupt方法,线程会抛出InterruptedException,然后在catch块中重新设置中断状态并结束任务。
要想终止线程,必须在线程中调用:Thread.currentThread().interrupt();方法,而不是外部调用。

二、打断线程

1、打断new出来的线程

  • 也可以把线程交给spring管理
  • 直接new一个线程,然后在需要打断的地方进行打断,示例:
package com.cc.jschdemo.terminationThread;

/**
 * <p>基本打断</p>
 *
 * @author cc
 * @since 2023/11/23
 */
public class BasicInterrupt {

    /**
     * 终止
     * @param args
     */
    public static void main(String[] args) {
        //t1:模仿执行任务的线程
        Thread t1 = new Thread(() -> {
            try {
                //步奏1
                Thread.sleep(1000);
                System.out.println("完成:步奏1");

                //步奏2(模仿阻塞)
                while (true) {
                    Thread.sleep(1000);
                    System.out.println("完成:步奏2");
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
                //捕获异常:InterruptedException,然后打断
                //☆☆打断,终止当前线程☆☆
                Thread.currentThread().interrupt();
            }
        });

        //t2:模仿其他操作,打断线程
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(3100);
                System.out.println("打断线程!");
                //打断t1线程
                t1.interrupt();
            }catch (Exception e) {
                e.printStackTrace();
            }
        });

        //启动两个线程
        t1.start();
        t2.start();
    }
}
  • 测试结果:步奏1执行1次,步奏2执行两次,然后t1线程就会被t2线程终止
  • 线程被打断会抛出错误:java.lang.InterruptedException: sleep interrupted

2、打断注入spring的线程

  • 新建线程,注入spring中
  • ps:注意,注入spring的线程是单例的,实际使用过程中,我们都是一个线程一个任务,如果需要不同的对象,可以开启spring的多例,见:SpringBoot实现多例模式
package com.cc.jschdemo.terminationThread;

import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.stereotype.Component;

/**
 * <p>注入spring的线程</p>
 *
 * @author --
 * @since 2023/11/24
 */
@EqualsAndHashCode(callSuper = true)
@Data
@Component
public class SpringThread extends Thread{

    //1可以注入Spring的Bean,然后直接使用
//    @Resource
//    private IBasicInterruptService basicInterruptService;

    //2可以直接传入执行任务的参数(可多个)
    private String footwork;

    /**
     * 具体要执行的任务
     */
    @Override
    public void run() {
        try {
            //步奏1
            Thread.sleep(1000);
            System.out.printf("完成:%s 1 %n", footwork);

            //步奏2(模仿阻塞)
            while (true) {
                Thread.sleep(1000);
                System.out.printf("完成:%s 2 %n", footwork);
            }
        }catch (InterruptedException e) {
            e.printStackTrace();
            //捕获异常:InterruptedException,然后打断
            //☆☆打断,终止当前线程☆☆
            Thread.currentThread().interrupt();
        }
    }
}
  • 创建任务,模仿打断
    //可以直接注入线程
    @Resource
    private SpringThread springThread;
    
    //模仿创建任务、打断
    @Test
    public void test07()throws Exception{
        try {
            ///传入执行任务,需要的参数
            springThread.setFootwork("步奏");
            //启动线程
            springThread.start();

            Thread.sleep(3100);
            System.out.println("打断线程!");
            //打断t1线程
            springThread.interrupt();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
  • 结果:和《打断new出来的线程》一模一样

3、打断CompletableFuture启动的线程

  • CompletableFuture的cancel(true)方法无法打断
  • 调用线程的Thread task1,的interrupt也无法打断
  • CompletableFuture.runAsync(task1)启动线程task1的底层逻辑是:CompletableFuture调用ForkJoinPool线程池启动一个线程(A)去执行task1任务。
  • 所以我们要打断的不是task1,而是要打断A
package com.cc.jschdemo.terminationThread;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

/**
 * <p></p>
 *
 * @author --
 * @since 2023/11/25
 */
@RestController
@RequestMapping("/completableFuture")
public class CompletableFutureThread {

    //这里使用标记打断的话,每个CompletableFuture都需要一个标记,可以(CompletableFuture和标记)一起缓存下来。
    boolean flagTask1 = false;
    boolean flagTask2 = false;

    //模仿任务1线程,也可以是:Runnable
    Thread task1 = new Thread(() -> {
        try {
            //模仿线程无限阻塞(while (true))
            while (true) {
                System.out.println("任务1执行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                //检查终止状态,如果终止就报错。true已中断;false未中断
                // 这里获取到的是:CompletableFuture启动线程池的线程池的线程。就是执行task1的线程
                boolean interrupted = Thread.currentThread().isInterrupted();
                // 所以interrupted不能用来终止task1

                //这里使用标记来终止task1(可以根据业务,在需要终止的地方设置这个打断。)
                if (flagTask1) {
                    //打断:CompletableFuture启动线程池的线程池的线程
                    Thread.currentThread().interrupt();
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    });

    //任务2
    Thread task2 = new Thread(() -> {
        try {
            //模仿线程阻塞
            while (true) {
                System.out.println("任务2执行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                //这里使用标记来终止task1
                if (flagTask2) {
                    Thread.currentThread().interrupt();
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    });

    //缓存CompletableFuture
    CompletableFuture<Void> future1;
    CompletableFuture<Void> future2;

    //启动任务
    @GetMapping
    public void test08()throws Exception{
        //实际使用中,可以使用循环添加CompletableFuture,然后记录下future(缓存),在要中断的逻辑中调用cancel
        //1开启task任务。这里实际是CompletableFuture调用ForkJoinPool线程池启动一个线程去执行task1任务。
        //要想终止任务,要终止CompletableFuture调用ForkJoinPool线程池创建的线程,而非task1线程。
        future1 = CompletableFuture.runAsync(task1);
        future2 = CompletableFuture.runAsync(task2);
    }

    //终止任务
    @PostMapping
    public void stop() {
        //3取消任务
        // 参数true表示尝试中断任务执行
        // cancel方法会尝试取消任务的执行,参数true表示尝试中断任务执行。
        // 成功取消返回true,否则返回false。
        // 需要注意的是,cancel方法并不会直接中断正在执行的线程,而是会尝试取消任务的执行,
        // 具体是否成功取决于任务的实现。

        //终止方式1:使用cancel终止:无法终止task1
        boolean cancel1 = future1.cancel(Boolean.TRUE);
        System.out.println("任务1终止:" + (cancel1 ? "成功1" : "失败1"));
        //终止方式2:打断线程task1:无法终止task1
        task1.interrupt();

        //睡5s,让任务跑5s,看终止方式1、2是否能终止,测试结果为:不能终止
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        //终止方式3:直接标记打断。CompletableFuture调用ForkJoinPool线程池生成的线程
        // 真正的终止task1
        flagTask1 = true;
    }
}



  • 测试

  • 终止方式1/2都执行了。但是任务没有终止

  • 终止方式3执行后,才真正的终止了。

热门相关:觅仙道   跟总裁假结婚的日子   跟总裁假结婚的日子   龙印战神   重生复仇:腹黑千金不好惹