java线程池线程超时关闭的两种我认为比较好的方式

绝地灬酷狼 2022-12-02 01:06 147阅读 0赞

问题：比如多线程进行io操作的时候，io的读取在等待的时候（比如telnet某端口时，会长时间等待），线程是不会关闭的，这样导致线程不释放，早晚凉凉。

线程池关闭线程的方式有很多，我使用以下两种，简单介绍下，希望能帮助到你。

1、编写守护线程，来关闭你的当前线程

思路：创建守护线程执行业务操作，编写用户线程超时退出，当用户线程退出后，守护线程将强制退出。代码如下：

package BK2020.M08.D27;
    
    /**
     * @description:
     * @Author: huangsan
     * @Date: 2020/8/28 9:34 下午
     */
    public class TimeOutThread extends Thread {
    
        @Override
        public void run() {
            try {
                Thread.sleep(3000);
                System.out.println("超时结束了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            DeamonThread t1 = new DeamonThread();
            TimeOutThread t2 = new TimeOutThread();
            t1.setDaemon(true);
            t1.start();
            t2.start();
        }
    }

package BK2020.M08.D27;
    
    /**
     * @description:
     * @Author: huangsan
     * @Date: 2020/8/28 9:30 下午
     */
    public class DeamonThread extends Thread {
    
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(99999999);//模拟IO等待
                } catch (InterruptedException e) {
                    System.out.println("强制中断");
                }
                break;
            }
        }
    
    }

2、使用future来实现

思路：通过future的get超时方法，超时的部分直接废弃掉，调用shutdownNow关闭其他线程，针对线程做异常处理

通过查看shutdown与shutdownNow我们可以知道，shutdown是会将等待状态下线程继续执行不会关闭的，解决不了我们的问题，所以使用shutdownNow强制关闭，但是这样的话我们的线程就会抛出异常，做好异常的处理即可。代码如下：

package BK2020.M08.D27;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.concurrent.*;
    
    /**
     * @description:
     * @Author: huangsan
     * @Date: 2020/8/28 8:49 下午
     */
    public class ThreadPoolCloseDemo {
    
        public static void main(String[] args) {
            allDeviceStatusMonitor();
        }
    
        public static void allDeviceStatusMonitor() {
            ThreadPoolExecutor myExecutor = new ThreadPoolExecutor(
                    32,
                    64,
                    20,
                    TimeUnit.SECONDS,
                    new SynchronousQueue<>());
            List<String> onlineIp = new ArrayList<>();
    
            List<String> ips = Arrays.asList("10.0.30.50", "10.0.30.51");
            List<Future> futureList = new ArrayList<>();
            for (String ip : ips) {
                //应用telnet
                Future<String> submit = myExecutor.submit(
                        () -> {
                            if (doTelnet(ip, "8080")) {
                                return ip;
                            }
                            return "xxx";
                        });
                futureList.add(submit);
            }
    
            for (Future<String> future : futureList) {
                try {
                    //超时后将放弃该状态，默认为离线
                    String ip = future.get(2, TimeUnit.SECONDS);
                    onlineIp.add(ip);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    System.out.println("超时放弃");
                }
            }
    
            //尝试关闭线程池，如果后续还有等待线程调用shutdownnow
            myExecutor.shutdown();
            try {
                if (!myExecutor.awaitTermination(2, TimeUnit.SECONDS)) {
                    myExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                myExecutor.shutdownNow();
            }
            System.out.println("全体在线设备及系统：" + onlineIp);
        }
    
        private static boolean doTelnet(String telnetIp, String telnetPort) {
            if ("10.0.30.50".equals(telnetIp)) {
                return true;
            }
            while (true) {
                try {
                    Thread.sleep(99999999);//模拟IO等待
                } catch (InterruptedException e) {
                    System.out.println("强制中断");
                }
                return false;
            }
        }
    }