想让一个线程停下来的几种方法

经常我们会有那种不关心某一段代码何时处理完毕的情况，这样我们就可以做成异步处理，那么开启线程处理数据逻辑是我们开发人员经常碰到的问题。

1、使用线程的interrupt()方法，不过此方法是给线程一个停止标记，并没有立刻停止线程，但是我们可以巧妙的用isInterrupted()方法和抛异常的方法，做到让线程停下来。

线程工厂：

package com.genius.technology.threadPool;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author xiarg
 * @CreateTime 2022/11/16  9:46
 */
public class AtfRiskThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    AtfRiskThreadFactory(String name) {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        if(name == null || "".equals(name.trim())){
            name = "pool";
        }
        namePrefix = name + "-" +
                poolNumber.getAndIncrement() +
                "-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon()){
            t.setDaemon(false);
        }
        if (t.getPriority() != Thread.NORM_PRIORITY){
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }
}

线程池和测试：

package com.genius.technology.threadPool;

import lombok.Data;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author xiarg
 * @CreateTime 2022/08/29  18:40
 */
@Component
public class ThreadPoolHandle {

    private static ThreadPoolExecutor threadPool;

    static {
        System.out.println("The Runner start to initialize ...");
        //创建线程池
        threadPool = new ThreadPoolExecutor(
                //线程池中的常驻核心线程数(假设银行窗口一般情况下开两个)
                8,
                //线程池能够容纳同时执行的最大线程数，此值必须>=1(特殊情况下比如周末办理业务人多，增设到5个窗口)
                16,
                //多余的空闲线程的存活时间 当前线程池数量超过 "corepoolsize"(认为有问题 应该是超过 maximumpoolsize吧)
                1L,
                // 当空闲时间达到keepalivetime值时，多余空闲线程会被销毁直到只剩下 corePoolSize个线程为止
                //unit keepAliveTime的单位
                TimeUnit.SECONDS,
                //任务队列，被提交但尚未被执行的任务（银行窗口的等待区的座位）
                new LinkedBlockingQueue<>(100),
                //线程工厂，用于生成线程池中的工作线程
                new AtfRiskThreadFactory("dataHandlePool"),
                //拒绝策略，当任务队列[LindedBlockingQueue]满了,
                // 并且工作线程[自己理解为办理业务的总认识，如以下代码中的10]大于等于线程池的最大线程数时如何拒绝多余工作线程
                new ThreadPoolExecutor.AbortPolicy()
        );
        threadPool.allowCoreThreadTimeOut(true);
    }
    public static ThreadPoolExecutor getThreadPool(){
        return threadPool;
    }

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = ThreadPoolHandle.getThreadPool();
        String[] threadNames = new String[1];
        threadPool.execute(() -> {
            System.out.println("线程启动了");
            threadNames[0] = Thread.currentThread().getName();
            try {
                while (true){
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("线程被标记停止");
                        throw new InterruptedException("线程被标记停止，抛出此异常");
                    }
                }
            } catch (InterruptedException e) {
                System.out.println("异常被catch到");
            } finally {
                System.out.println("线程停止的收尾工作");
            }
        });

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        while(true){
            String threadName = threadNames[0];
            Thread myThread = null;
            for (Thread thread : Thread.getAllStackTraces().keySet()) {
                if (thread.getName().equals(threadName)) {
                    System.out.println("找到线程 : "+thread.getName());
                    myThread = thread;
                    break;
                }
            }
            if(myThread == null){
                System.out.println("没找到线程");
            }else {
                System.out.println(threadName +" 线程被interrupt");
                myThread.interrupt();
            }
            break;
        }
    }
}