服务器之家

服务器之家 > 正文

Java 并发编程之线程挂起、恢复与终止

时间:2020-09-24 15:55     来源/作者:牛头人

挂起恢复线程

    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
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); //中断应用程序
 }
}

    某次运行结果如下:

Java 并发编程之线程挂起、恢复与终止

    从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
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); //退出应用程序
 }
}

    运行结果如下:

Java 并发编程之线程挂起、恢复与终止

   线程挂起的位置不确定main线程中执行asr.areValuesEqual()进行比较时,恰逢stepOne操作执行完,而stepTwo操作还没执行)asr.areValuesEqual()操作前,让main线程休眠450ms(>300ms),如果挂起请求发出时,新线程正执行到或即将执行到stepOne操作(如果在其前面的话,就会响应挂起请求,从而挂起线程),那么在stepTwo操作执行前,main线程的休眠还没结束,从而main线程休眠结束后执行asr.areValuesEqual()操作进行比较时,stepTwo操作已经执行完,因此也不会出现输出结果为false的情况。

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

Java 并发编程之线程挂起、恢复与终止

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

终止线程

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

以上所述是小编给大家介绍的Java 并发编程之线程挂起、恢复与终止,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!

原文链接:http://www.cnblogs.com/web424/p/6807319.html

标签:

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
Intellij idea2020永久破解,亲测可用!!!
Intellij idea2020永久破解,亲测可用!!! 2020-07-29
歪歪漫画vip账号共享2020_yy漫画免费账号密码共享
歪歪漫画vip账号共享2020_yy漫画免费账号密码共享 2020-04-07
电视剧《琉璃》全集在线观看 琉璃美人煞1-59集免费观看地址
电视剧《琉璃》全集在线观看 琉璃美人煞1-59集免费观看地址 2020-08-12
最新idea2020注册码永久激活(激活到2100年)
最新idea2020注册码永久激活(激活到2100年) 2020-07-29
返回顶部