一.多线程基本篇-1.7 采用优雅的方式结束线程生命周期

╰+攻爆jí腚メ 2022-12-07 11:42 31阅读 0赞

**如何中断一个线程**

*  通过一个开关

import java.util.concurrent.TimeUnit;
    
    public class ThreadCloseForce {
    
        public static class Work extends Thread{
            private volatile boolean state = true;
    
            @Override
            public void run(){
                while (state){
    
                }
            }
    
            public void shutdown(){
                state = false;
            }
        }
    
    
        public static void main(String[] args) {
            Work work = new Work();
            work.start();
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
            }
    
            work.shutdown();
        }
    }

*  通过中断机制

import java.util.concurrent.TimeUnit;
    
    public class ThreadCloseForce {
    
        public static class Work extends Thread{
    
            @Override
            public void run(){
                while (true){
                    if (this.isInterrupted()){
                        break;
                    }
                }
            }
    
        }
    
    
        public static void main(String[] args) {
            Work work = new Work();
            work.start();
    
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
            }
    
            work.interrupt();
        }
    }

*  使用daemon线程  
    利用守护线程生命周期离不开用户线程的特点，以及join保持线程执行顺序的特点

public class ThreadService  {
        private Thread userThread;
        private boolean finished = false;
        public void execute(Runnable task){
            userThread = new Thread(){
                @Override
                public  void run(){
                    Thread  work = new Thread(task);
                    work.setDaemon(true);
                    work.start();
                    try {
                        work.join();
                        finished = true;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                    }
                }
            };
    
            userThread.start();
        }
    
        public void shoutdown(long time){
            long current = System.currentTimeMillis();
            while (!finished){
                long span = System.currentTimeMillis() - current;
                System.out.println("span: " + span);
                if (span > time){
                    System.out.println("执行线程超时!");
                    userThread.interrupt();
                    break;
                }
                try {
                    userThread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("执行线程被打断!");
                    break;
                }
            }
    
            finished = false;
        }
    }
    
    public class ThreadInterrupt {
        public static void main(String[] args)  {
            ThreadService servce = new ThreadService();
    
            servce.execute(()->{
                  //long long time to load
    //            while (true){
    //
    //            }
                try {
                    Thread.sleep(5_000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
    
            long start = System.currentTimeMillis();
            servce.shoutdown(10_000);
            long end = System.currentTimeMillis();
            System.out.println("stop time: " + (end - start));
    
        }
    }