stop thread

Author: CodePrometheus

README.md

@@ -3,7 +3,9 @@ Java并发编程
 
 
 ## 线程
-     创造线程
+     创建线程的两种方法
+     正确启动线程
+     正确停止线程
      ThreadPool
      ThreadLocal
 

Thread/src/stopthread/StopThreadSummary.java

@@ -0,0 +1,18 @@
+package stopthread;
+
+/**
+ * 停止线程总结 错误
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 16:25
+ */
+public class StopThreadSummary {
+
+    /**
+     * 正确停止线程
+     *      -> 使用interrupt来通知，而不是强制 （让被停止的线程本身决定后续工作）
+     *      -> 想停止线程，要请求方、被停止方、子方法被调用者方相互配合
+     *      -> stop/suspend 已废弃，volatile的boolean无法处理长时间阻塞的情况
+     */
+}
+

Thread/src/stopthread/rightway/CantInterrupt.java

@@ -0,0 +1,35 @@
+package stopthread.rightway;
+
+/**
+ * 注意 ->
+ * 如果while里面放try/catch，会导致中断失效
+ *
+ * 因为sleep设计时一旦响应中断，就会把线程interrupt标记位为清除
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 17:10
+ */
+public class CantInterrupt {
+    public static void main(String[] args) throws InterruptedException {
+        Runnable runnable = () -> {
+            int num = 0;
+            //补充中断也效果
+            while (num <= 10000 && !Thread.currentThread().isInterrupted()) {
+                if (num % 100 == 0) {
+                    System.out.println(num + "是100的倍数");
+                }
+                num++;
+                //程序将会继续运行
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+        };
+        Thread thread = new Thread(runnable);
+        thread.start();
+        Thread.sleep(500);
+        thread.interrupt();
+    }
+}

Thread/src/stopthread/rightway/RightWayStopThreadInProd.java

@@ -0,0 +1,37 @@
+package stopthread.rightway;
+
+/**
+ * 生产实践中，停止线程的最佳方法
+ * -> catch了InterruptedException之后优先选择 ->在方法签名中抛出异常
+ * 那么在run()就会强制try/catch，且只有try这个方法，因为run方法为顶层函数，无法抛出checked Exception
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 17:26
+ */
+public class RightWayStopThreadInProd implements Runnable {
+
+    @Override
+    public void run() {
+        while (!Thread.currentThread().isInterrupted()) {
+            System.out.println("gogogo");
+            try {
+                throwInMethod();
+            } catch (InterruptedException e) {
+                System.out.println("正确响应处理中断请求");
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void throwInMethod() throws InterruptedException {
+        //这里抛出
+        Thread.sleep(1000);
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread = new Thread(new RightWayStopThreadInProd());
+        thread.start();
+        Thread.sleep(1000);
+        thread.interrupt();
+    }
+}

Thread/src/stopthread/rightway/RightWayStopThreadInProdSecond.java

@@ -0,0 +1,38 @@
+package stopthread.rightway;
+
+/**
+ * @Description: 在catch子语句中调用Thread.currentThread().interrupt()来恢复设置中断状态，以便在后续的执行中
+ * 依然能够检查到刚才发生了中断
+ * @Author: zzStar
+ * @Date: 2020/10/14 17:47
+ */
+public class RightWayStopThreadInProdSecond implements Runnable {
+
+    @Override
+    public void run() {
+        while (true) {
+            if (Thread.currentThread().isInterrupted()) {
+                System.out.println("Interrupted,程序运行结束🔚");
+                break;
+            }
+            reInterrupt();
+        }
+    }
+
+    private void reInterrupt() {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            //没有这个调用run方法里不会打印出，无法感知中断
+            Thread.currentThread().interrupt();
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread = new Thread(new RightWayStopThreadInProdSecond());
+        thread.start();
+        Thread.sleep(1000);
+        thread.interrupt();
+    }
+}

Thread/src/stopthread/rightway/RightWayStopThreadWithSleep.java

@@ -0,0 +1,31 @@
+package stopthread.rightway;
+
+/**
+ * 带有sleep中断线程的写法
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 16:51
+ */
+public class RightWayStopThreadWithSleep {
+
+    public static void main(String[] args) throws InterruptedException {
+        Runnable runnable = () -> {
+            int num = 0;
+            try {
+                while (num <= 300 && !Thread.currentThread().isInterrupted()) {
+                    if (num % 100 == 0) {
+                        System.out.println(num + "是100的倍数");
+                    }
+                    num++;
+                }
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();//java.lang.InterruptedException: sleep interrupted
+            }
+        };
+        Thread thread = new Thread(runnable);
+        thread.start();
+        Thread.sleep(500);
+        thread.interrupt();
+    }
+}

Thread/src/stopthread/rightway/RightWayStopThreadWithSleepEveryLoop.java

@@ -0,0 +1,31 @@
+package stopthread.rightway;
+
+/**
+ * 线程在每次迭代后都阻塞,也即每次循环都会调用sleep或wait方法，则不需要每次迭代都检查是否已中断
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 17:02
+ */
+public class RightWayStopThreadWithSleepEveryLoop {
+    public static void main(String[] args) throws InterruptedException {
+        Runnable runnable = () -> {
+            int num = 0;
+            try {
+                //这里无需在要一个判断
+                while (num <= 3000) {
+                    if (num % 100 == 0) {
+                        System.out.println(num + "是100的倍数");
+                    }
+                    num++;
+                    Thread.sleep(100);
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();//java.lang.InterruptedException: sleep interrupted
+            }
+        };
+        Thread thread = new Thread(runnable);
+        thread.start();
+        Thread.sleep(500);
+        thread.interrupt();
+    }
+}

Thread/src/stopthread/rightway/RightWayStopThreadWithoutSleep.java

@@ -0,0 +1,31 @@
+package stopthread.rightway;
+
+import static java.lang.Integer.MAX_VALUE;
+
+/**
+ * run方法内没有sleep或wait方法时，停止线程
+ *
+ * @Author: zzStar
+ * @Date: 10-14-2020 16:37
+ */
+public class RightWayStopThreadWithoutSleep implements Runnable {
+
+    @Override
+    public void run() {
+        int num = 0;
+        while (!Thread.currentThread().isInterrupted() && num <= MAX_VALUE / 2) {
+            if (num % 10000 == 0) {
+                System.out.println(num + "是10000的倍数");
+            }
+            num++;
+        }
+        System.out.println("任务结束了");
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        Thread thread = new Thread(new RightWayStopThreadWithoutSleep());
+        thread.start();
+        Thread.sleep(1000);
+        Thread.interrupted();
+    }
+}

Thread/src/stopthread/wrongway/StopThread.java

@@ -0,0 +1,48 @@
+package stopthread.wrongway;
+
+/**
+ * 错误地停止线程stop()，会导致线程运行一半突然停止，没办法完成一个基本单位地操作
+ * 造成脏数据
+ * <p>
+ * 注意！
+ * 因为stop本质上是不安全的，停止线程会导致它解锁！已锁定的所有监视器，
+ * 如果先前受这些监视器保护的任何对象处于不一致状态，则其他线程现在可以以不一致的状态查看这些对象
+ *
+ * @Author: zzStar
+ * @Date: 10-15-2020 16:35
+ */
+public class StopThread implements Runnable {
+    @Override
+    public void run() {
+        //5个联队
+        for (int i = 0; i < 5; i++) {
+            System.out.println("连队" + i + "领取武器");
+            //每个连队10个人
+            for (int j = 0; j < 10; j++) {
+                System.out.println(j);
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            System.out.println("连队" + i + "已经领取完毕");
+        }
+    }
+
+    public static void main(String[] args) {
+        Thread thread = new Thread(new StopThread());
+        thread.start();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+/*
+        thread.stop();
+        //suspend会让一个线程挂起，在恢复之前锁不会释放，也就是带着锁休息，易造成死锁
+        thread.suspend();
+        thread.resume();
+*/
+    }
+}

Thread/src/stopthread/wrongway/WrongWayVolatile.java

@@ -0,0 +1,41 @@
+package stopthread.wrongway;
+
+/**
+ * 演示Volatile的局限 -> part1 看似可行
+ *
+ * @Author: zzStar
+ * @Date: 10-15-2020 16:52
+ */
+public class WrongWayVolatile implements Runnable {
+    //可见性
+    private volatile boolean canceled = false;
+
+    @Override
+    public void run() {
+        int num = 0;
+        try {
+            while (num <= 10000 && !canceled) {
+                if (num % 100 == 0) {
+                    System.out.println(num + "是100的倍数");
+                }
+                num++;
+                Thread.sleep(1);
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        WrongWayVolatile wrongWayVolatile = new WrongWayVolatile();
+        Thread thread = new Thread(wrongWayVolatile);
+        thread.start();
+        try {
+            //使当前线程休眠，进入阻塞状态（暂停执行）
+            Thread.sleep(3000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        wrongWayVolatile.canceled = true;
+    }
+}