挂起和恢复线程

Thread 的API中包含两个被淘汰的方法，它们用于临时挂起和重启某个线程，这些方法已经被淘汰，因为它们是不安全的，不稳定的。如果在不合适的时候挂起线程（比如，锁定共享资源时），此时便可能会发生死锁条件——其他线程在等待该线程释放锁，但该线程却被挂起了，便会发生死锁。另外，在长时间计算期间挂起线程也可能导致问题。

下面的代码演示了通过休眠来延缓运行，模拟长时间运行的情况，使线程更可能在不适当的时候被挂起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class DeprecatedSuspendResume extends Object implements Runnable{
    //volatile关键字，表示该变量可能在被一个线程使用的同时，被另一个线程修改
    private volatile int firstVal;
    private volatile int secondVal;
    //判断二者是否相等
    public boolean areValuesEqual(){
        return ( firstVal == secondVal);
    }
    public void run() {
        try{
            firstVal = 0;
            secondVal = 0;
            workMethod();
        }catch(InterruptedException x){
            System.out.println("interrupted while in workMethod()");
        }
    }
    private void workMethod() throws InterruptedException {
        int val = 1;
        while (true){
            stepOne(val);
            stepTwo(val);
            val++;
            Thread.sleep(200);  //再次循环钱休眠200毫秒
        }
    }
    //赋值后，休眠300毫秒，从而使线程有机会在stepOne操作和stepTwo操作之间被挂起
    private void stepOne(int newVal) throws InterruptedException{
        firstVal = newVal;
        Thread.sleep(300);  //模拟长时间运行的情况
    }
    private void stepTwo(int newVal){
        secondVal = newVal;
    }
    public static void main(String[] args){
        DeprecatedSuspendResume dsr = new DeprecatedSuspendResume();
        Thread t = new Thread(dsr);
        t.start();
        //休眠1秒，让其他线程有机会获得执行
        try {
            Thread.sleep(1000);}
        catch(InterruptedException x){}
        for (int i = 0; i < 10; i++){
            //挂起线程
            t.suspend();
            System.out.println("dsr.areValuesEqual()=" + dsr.areValuesEqual());
            //恢复线程
            t.resume();
            try{
                //线程随机休眠0~2秒
                Thread.sleep((long)(Math.random()*2000.0));
            }catch(InterruptedException x){
                //略
            }
        }
        System.exit(0); //中断应用程序
    }
}

某次运行结果如下：

从areValuesEqual（）返回的值有时为true，有时为false。以上代码中，在设置firstVal之后，但在设置secondVal之前，挂起新线程会产生麻烦，此时输出的结果会为false（情况1），这段时间不适宜挂起线程，但因为线程不能控制何时调用它的suspend方法，所以这种情况是不可避免的。

当然，即使线程不被挂起（注释掉挂起和恢复线程的两行代码），如果在main线程中执行asr.areValuesEqual（）进行比较时，恰逢stepOne操作执行完，而stepTwo操作还没执行，那么得到的结果同样可能是false（情况2）。
下面我们给出不用上述两个方法来实现线程挂起和恢复的策略——设置标志位。通过该方法实现线程的挂起和恢复有一个很好的地方，就是可以在线程的指定位置实现线程的挂起和恢复，而不用担心其不确定性。

对于上述代码的改进代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
public class AlternateSuspendResume extends Object implements Runnable {
    private volatile int firstVal;
    private volatile int secondVal;
    //增加标志位，用来实现线程的挂起和恢复
    private volatile boolean suspended;
    public boolean areValuesEqual() {
        return ( firstVal == secondVal );
    }
    public void run() {
        try {
            suspended = false;
            firstVal = 0;
            secondVal = 0;
            workMethod();
        } catch ( InterruptedException x ) {
            System.out.println("interrupted while in workMethod()");
        }
    }
    private void workMethod() throws InterruptedException {
        int val = 1;
        while ( true ) {
            //仅当贤臣挂起时，才运行这行代码
            waitWhileSuspended();
            stepOne(val);
            stepTwo(val);
            val++;
            //仅当线程挂起时，才运行这行代码
            waitWhileSuspended();
            Thread.sleep(200); 
        }
    }
    private void stepOne(int newVal)
                    throws InterruptedException {
        firstVal = newVal;
        Thread.sleep(300); 
    }
    private void stepTwo(int newVal) {
        secondVal = newVal;
    }
    public void suspendRequest() {
        suspended = true;
    }
    public void resumeRequest() {
        suspended = false;
    }
    private void waitWhileSuspended()
                throws InterruptedException {
        //这是一个“繁忙等待”技术的示例。
        //它是非等待条件改变的最佳途径，因为它会不断请求处理器周期地执行检查，
        //更佳的技术是：使用Java的内置“通知-等待”机制
        while ( suspended ) {
            Thread.sleep(200);
        }
    }
    public static void main(String[] args) {
        AlternateSuspendResume asr =
                new AlternateSuspendResume();
        Thread t = new Thread(asr);
        t.start();
        //休眠1秒，让其他线程有机会获得执行
        try { Thread.sleep(1000); }
        catch ( InterruptedException x ) { }
        for ( int i = 0; i < 10; i++ ) {
            asr.suspendRequest();
            //让线程有机会注意到挂起请求
            //注意：这里休眠时间一定要大于
            //stepOne操作对firstVal赋值后的休眠时间，即300ms，
            //目的是为了防止在执行asr.areValuesEqual（）进行比较时,
            //恰逢stepOne操作执行完，而stepTwo操作还没执行
            try { Thread.sleep(350); }
            catch ( InterruptedException x ) { }
            System.out.println("dsr.areValuesEqual()=" +
                    asr.areValuesEqual());
            asr.resumeRequest();
            try {
                //线程随机休眠0~2秒
                Thread.sleep(
                        ( long ) (Math.random() * 2000.0) );
            } catch ( InterruptedException x ) {
                //略
            }
        }
        System.exit(0); //退出应用程序
    }
}

运行结果如下：

由结果可以看出，输出的所有结果均为true。首先，针对情况1（线程挂起的位置不确定），这里确定了线程挂起的位置，不会出现线程在stepOne操作和stepTwo操作之间挂起的情况；针对情况2（main线程中执行asr.areValuesEqual（）进行比较时，恰逢stepOne操作执行完，而stepTwo操作还没执行），在发出挂起请求后，还没有执行asr.areValuesEqual（）操作前，让main线程休眠450ms（>300ms），如果挂起请求发出时，新线程正执行到或即将执行到stepOne操作（如果在其前面的话，就会响应挂起请求，从而挂起线程），那么在stepTwo操作执行前，main线程的休眠还没结束，从而main线程休眠结束后执行asr.areValuesEqual（）操作进行比较时，stepTwo操作已经执行完，因此也不会出现输出结果为false的情况。

可以将ars.suspendRequest（）代码后的sleep代码去掉，或将休眠时间改为200（明显小于300即可）后，查看执行结果，会发现结果中依然会有出现false的情况。如下图所示：

总结：线程的挂起和恢复实现的正确方法是：通过设置标志位，让线程在安全的位置挂起

终止线程

当调用Thread的start（）方法，执行完run（）方法后，或在run（）方法中return，线程便会自然消亡。另外Thread API中包含了一个stop（）方法，可以突然终止线程。但它在JDK1.2后便被淘汰了，因为它可能导致数据对象的崩溃。一个问题是，当线程终止时，很少有机会执行清理工作；另一个问题是，当在某个线程上调用stop（）方法时，线程释放它当前持有的所有锁，持有这些锁必定有某种合适的理由——也许是阻止其他线程访问尚未处于一致性状态的数据，突然释放锁可能使某些对象中的数据处于不一致状态，而且不会出现数据可能崩溃的任何警告。

终止线程的替代方法：同样是使用标志位，通过控制标志位来终止线程。

from: http://www.importnew.com/20539.html

原文出处： 兰亭风雨

Java并发编程（3）：线程挂起、恢复与终止的正确方法（含代码）相关推荐

  1. 【Java 并发编程】线程池机制 ( ThreadPoolExecutor 线程池构造参数分析 | 核心线程数 | 最大线程数 | 非核心线程存活时间 | 任务阻塞队列 )

    文章目录 前言 一.ThreadPoolExecutor 构造参数 二.newCachedThreadPool 参数分析 三.newFixedThreadPool 参数分析 四.newSingleTh ...

  2. 【Java 并发编程】线程池机制 ( 线程池示例 | newCachedThreadPool | newFixedThreadPool | newSingleThreadExecutor )

    文章目录 前言 一.线程池示例 二.newCachedThreadPool 线程池示例 三.newFixedThreadPool 线程池示例 三.newSingleThreadExecutor 线程池 ...

  3. （转）Java并发编程：线程池的使用

    背景:线程池在面试时候经常遇到,反复出现的问题就是理解不深入,不能做到游刃有余.所以这篇博客是要深入总结线程池的使用. ThreadPoolExecutor的继承关系 线程池的原理 1.线程池状态(4 ...

  4. java并发编程与线程安全

    2019独角兽企业重金招聘Python工程师标准>>> 什么是线程安全 如果对象的状态变量(对象的实例域.静态域)具有可变性,那么当该对象被多个线程共享时就的考虑线程安全性的问题,否 ...

  5. 19、Java并发编程：线程间协作的两种方式：wait、notify、notifyAll和Condition

    Java并发编程:线程间协作的两种方式:wait.notify.notifyAll和Condition 在前面我们将了很多关于同步的问题,然而在现实中,需要线程之间的协作.比如说最经典的生产者-消费者 ...

  6. JAVA并发编程3_线程同步之synchronized关键字

    在上一篇博客里讲解了JAVA的线程的内存模型,见:JAVA并发编程2_线程安全&内存模型,接着上一篇提到的问题解决多线程共享资源的情况下的线程安全问题. 不安全线程分析 public clas ...

  7. [转]Java并发编程：线程池的使用

    Java并发编程:线程池的使用 在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了, ...

  8. Java并发编程：线程的同步

    <?xml version="1.0" encoding="utf-8"?> Java并发编程:线程的同步 Java并发编程:线程的同步 Table ...

  9. Java并发编程一线程池简介

    推荐:Java并发编程汇总 Java并发编程一线程池简介 为什么我们需要使用线程池? 我们知道线程是一种比较昂贵的资源,我们通过程序每创建一个线程去执行,其实操作系统都会对应地创建一个线程去执行我们的 ...

  10. Java并发编程一线程池的五种状态

    推荐:Java并发编程汇总 Java并发编程一线程池的五种状态 原文地址 Java多线程线程池(4)–线程池的五种状态 正文 线程池的5种状态:Running.ShutDown.Stop.Tidyin ...

最新文章

  1. python全栈开发笔记---基本数据类型--数字型魔法
  2. redis安装 linux步骤,【linux安装redis完整步骤】
  3. DL之DNN：利用MultiLayerNetExtend模型【6*100+ReLU+SGD,dropout】对Mnist数据集训练来抑制过拟合
  4. 基于Kubernetes1.20.1版本开发调试环境搭建
  5. docker安装kibana7.6.1
  6. 肝！深度讲解Python四大常用绘图库的“绘图原理”
  7. 逗号表达式的值--最后一项的值
  8. RS232和RS485
  9. April 24, 17:30-20:00, 1479, Concentration-compactness/Rigidity method lecture 3 by Yang Lan
  10. mybatis 使用 mssql 报错 不支持从 UNKNOWN 到 UNKNOWN 的转换
  11. web多媒体标签，表格标签，超链接标签，语义化标签练习
  12. Ubuntu 改鼠标侧键为ctrl，并配合滚轮实现页面缩放
  13. MSM8260,OMAP4430,TEGRA2,EXYNOS 4210详细分析
  14. 超级管理器Android,超级文件管理器
  15. 外汇汇率接口 java_免费的货币汇率API
  16. 微生物组-扩增子16S分析第10期(报名直播课免费参加线下2020.10)
  17. 全球顶级的14位程序员！膜拜！
  18. redis命令之set和zset的操作
  19. 实体店防盗，RFID技术作用巨大
  20. 选择 Delphi 2007 ( CodeGear Delphi 2007 for Win32 Version 11.0.2837.9583 ) 的理由

热门文章

  1. 【统计学习】参数估计
  2. 【采用】【科技金融】互金风控大数据盘点
  3. GMIS 2017大会漆远演讲：AI 驱动金融生活
  4. 不是你无法入门自然语言处理（NLP），而是你没找到正确的打开
  5. 看样子还是：JSP和JAVA
  6. 信用经济中的经济因素
  7. RocketMQ-初体验RocketMQ(05)_RocketMQ架构解读
  8. 白话Elasticsearch10-深度探秘搜索技术之基于dis_max实现best fields策略进行多字段搜索
  9. 斜面孔如何绘制_journal of neuroscience：面孔的神经表征与眼动模式相协调
  10. Android之----Log详解(Log.v,Log.d,Log.i,Log.w,Log.e)