Java并发编程之停止线程

悠悠 2023-07-10 03:00 27阅读 0赞

## 1. 线程在什么情况下会停止？ ##

在三种情况下会导致线程停止：

*  run方法正常执行完毕
 *  执行过程中出现异常
 *  其它线程干预当前线程，如interrupt、volatile修饰的标识符、已经被弃用的stop、suspend等方法

## 2. 停止线程的正确方法：interrupt ##

使用interrupt来通知需要被停止的线程以及该线程如何配合，而不是强制停止，因为被停止的线程对本身的业务逻辑是最熟悉的，而发出停止信号的线程对其业务逻辑是不了解的，我们只能告诉被停止的线程该中断了，而被中断的线程本身拥有最终决定权，这样可以保障数据安全。

1.  在非阻塞状态下停止线程

public class MyThreadNormal implements Runnable { 
        @Override
        public void run() { 
            int count = 0;
            while (!Thread.currentThread().isInterrupted()) { 
                System.out.println(count++);
            }
            System.out.println("线程被停止");
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadNormal());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

.......
    308827
    308828
    308829
    线程被停止

1.  在阻塞状态下停止线程

public class MyThreadSleep implements Runnable { 
        @Override
        public void run() { 
            System.out.println("开始阻塞");
            try { 
                Thread.sleep(5000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("结束阻塞");
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadSleep());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

开始阻塞
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at core.stop.right.MyThreadSleep.run(MyThreadSleep.java:8)
    	at java.lang.Thread.run(Thread.java:748)
    结束阻塞

public class MyThreadWait implements Runnable { 
        private Object obj = new Object();
        @Override
        public void run() { 
            System.out.println("开始阻塞");
            synchronized (obj) { 
                try { 
                    obj.wait();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("结束阻塞");
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadWait());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

开始阻塞
    java.lang.InterruptedException
    	at java.lang.Object.wait(Native Method)
    	at java.lang.Object.wait(Object.java:502)
    	at core.stop.right.MyThreadWait.run(MyThreadWait.java:10)
    	at java.lang.Thread.run(Thread.java:748)
    结束阻塞

wait方法和sleep方法都会导致阻塞状态，在阻塞状态下如果收到中断信号，便会响应中断，抛出异常。所以，如果代码中存在wait或sleep方法就没必要去写!Thread.currentThread().isInterrupted()去检测中断信号，因为前者已经能响应中断。

## 3. 中断线程的最佳实践 ##

在while中try/catch中存在以下问题：

public class MyThread implements Runnable { 
        @Override
        public void run() { 
            int count = 0;
            while (!Thread.currentThread().isInterrupted()) { 
                System.out.println(count++);
                try { 
                    Thread.sleep(1000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThread());
            thread.start();
            Thread.sleep(500);
            thread.interrupt();
        }
    }

0
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at core.stop.best.MyThread.run(MyThread.java:10)
    	at java.lang.Thread.run(Thread.java:748)
    1
    2

如上述代码所示，在while循环内try/catch时，主线程发出中断请求，子线程响应了中断并捕获异常，但是程序依然继续执行，那是因为一旦sleep方法响应中断，响应后就会把中断状态清除，所以再进行检查中断信号时是检查不到的。  
针对while内try/catch存在的问题，最佳解决方案是如果run方法中调用了其他方法且方法中需要抛出异常，那么久在被调用方法签名上抛出异常，并在catch中恢复中断，代码如下：

public class MyThreadOne implements Runnable { 
        @Override
        public void run() { 
            while (!Thread.currentThread().isInterrupted()) { 
                try { 
                    System.out.println("进入try");
                    throwMethod();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
        }
    
        private void throwMethod() throws InterruptedException { 
            Thread.sleep(2000);
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadOne());
            thread.start();
            Thread.sleep(1000);
            thread.interrupt();
        }
    }

进入try
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at core.stop.best.MyThreadOne.throwMethod(MyThreadOne.java:18)
    	at core.stop.best.MyThreadOne.run(MyThreadOne.java:9)
    	at java.lang.Thread.run(Thread.java:748)

上述代码的run方法中调用了throwMethod方法，throwMethod方法中调用了sleep方法并在方法签名上抛出异常，这样做的好处在于：

*  被调用方在方法签名上抛出异常，调用方必须捕获异常，这样调用方就可以处理这个异常，进而在catch中处理，比如重新标记中断状态，进而停止线程；
 *  如果直接在被调用方处理异常，那么调用方就不知道是否有异常，就无法定位到异常发生的位置。

## 4. 停止线程的错误方法：stop、suspend和volatile boolean标记位 ##

1.  stop方法会导致线程运行一半突然停止，没法完成一个基本单位的操作，造成脏数据
2.  suspend方法不会释放锁，如果没有被唤醒，容易造成死锁
3.  volatile boolean标记位
    
    1.  在非阻塞状态下停止线程

public class MyThreadVolatile implements Runnable { 
    
        private static volatile boolean canceled = false;
    
        @Override
        public void run() { 
            int count = 0;
            while (!canceled) { 
                System.out.println(count++);
            }
            System.out.println("线程结束");
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadVolatile());
            thread.start();
            Thread.sleep(500);
            MyThreadVolatile.canceled = true;
        }
    }

1.  在阻塞状态下停止线程

public class MyThreadVolatileSleep implements Runnable { 
    
        private static volatile boolean canceled = false;
    
        @Override
        public void run() { 
            while (!canceled) { 
                try { 
                    Thread.sleep(5000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束");
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadVolatileSleep());
            thread.start();
            Thread.sleep(500);
            MyThreadVolatileSleep.canceled = true;
        }
    }

因为sleep方法能响应interrupt方法中断线程，而不能响应volatile修饰的canceled关键字，所以在阻塞状态下，线程是无法中断的。

## 5. 停止线程相关重要函数解析 ##

Thread类中判断是否已被中断的方法如下：

*  interrupted方法，是Thread类的静态方法，判断完线程状态后会清除中断状态

public static boolean interrupted() { 
            return currentThread().isInterrupted(true);
        }

*  isInterrupted，不会清除中断状态

public boolean isInterrupted() { 
            return isInterrupted(false);
        }

*  Thread.interrupted()是个静态方法，该方法属于Thread类，而不属于子线程对象，所以该方法的目标对象是当前线程，即执行该方法的线程，而不管本方法由哪个对象调用的，比如：主线程中用子线程对象调用interrupted()方法，判断的是主线程，而不是子线程，代码如下：

public class MyThreadInterrupted implements Runnable { 
        @Override
        public void run() { 
            for (;;) { 
    
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new MyThreadInterrupted());
            thread.start();
            thread.interrupt();
            System.out.println(thread.isInterrupted());//子线程true
            System.out.println(thread.interrupted());//主线程false
            System.out.println(Thread.interrupted());//主线程false
            thread.join();
            System.out.println("主线程结束");
        }
    }

true
    false
    false