zoukankan      html  css  js  c++  java
  • Synchronized之三:Synchronized与线程中断、线程wait

    线程中断

    见《Thread之八:interrupt中断

    正如中断二字所表达的意义,在线程运行(run方法)中间打断它,在Java中,提供了以下3个有关线程中断的方法

    //中断线程(实例方法)
    public void Thread.interrupt();
    
    //判断线程是否被中断(实例方法)
    public boolean Thread.isInterrupted();
    
    //判断是否被中断并清除当前中断状态(静态方法)
    public static boolean Thread.interrupted();

    当一个线程处于被阻塞状态或者试图执行一个阻塞操作时,使用Thread.interrupt()方式中断该线程,注意此时将会抛出一个InterruptedException的异常,同时中断状态将会被复位(由中断状态改为非中断状态),如下代码将演示该过程:

    package com.dxz.synchronize;
    
    import java.util.concurrent.TimeUnit;
    
    public class InterruputSleepThread3 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    // while在try中,通过异常中断就可以退出run循环
                    try {
                        while (true) {
                            // 当前线程处于阻塞状态,异常必须捕捉处理,无法往外抛出
                            TimeUnit.SECONDS.sleep(2);
                        }
                    } catch (InterruptedException e) {
                        System.out.println("Interruted When Sleep");
                        boolean interrupt = this.isInterrupted();
                        // 中断状态被复位
                        System.out.println("interrupt:" + interrupt);
                    }
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            // 中断处于阻塞状态的线程
            t1.interrupt();
        }
    }

    结果:

    Interruted When Sleep
    interrupt:false

    如上述代码所示,我们创建一个线程,并在线程中调用了sleep方法从而使用线程进入阻塞状态,启动线程后,调用线程实例对象的interrupt方法中断阻塞状态,并抛出InterruptedException异常,此时中断状态也将被复位。这里有些人可能会诧异,为什么不用Thread.sleep(2000);而是用TimeUnit.SECONDS.sleep(2);其实原因很简单,前者使用时并没有明确的单位说明,而后者非常明确表达秒的单位,事实上后者的内部实现最终还是调用了Thread.sleep(2000);,但为了编写的代码语义更清晰,建议使用TimeUnit.SECONDS.sleep(2);的方式,注意TimeUnit是个枚举类型。

    除了阻塞中断的情景,我们还可能会遇到处于运行期且非阻塞的状态的线程,这种情况下,直接调用Thread.interrupt()中断线程是不会得到任响应的,如下代码,将无法中断非阻塞状态下的线程:

    package com.dxz.synchronize;
    
    import java.util.concurrent.TimeUnit;
    
    public class InterruputThread {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    while (true) {
                        System.out.println("未被中断");
                    }
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            t1.interrupt();
    
        }
    }

    结果:

    未被中断
    未被中断
    未被中断
    ...

    虽然我们调用了interrupt方法,但线程t1并未被中断,因为处于非阻塞状态的线程需要我们手动进行中断检测并结束程序,改进后代码如下:

    package com.dxz.synchronize;
    
    import java.util.concurrent.TimeUnit;
    
    public class InterruputThread {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    while (true) {
                        // 判断当前线程是否被中断
                        if (this.isInterrupted()) {
                            System.out.println("线程中断");
                            break;
                        }
                    }
    
                    System.out.println("已跳出循环,线程中断!");
                }
            };
            t1.start();
            TimeUnit.SECONDS.sleep(2);
            t1.interrupt();
        }
    }

    结果:

    线程中断
    已跳出循环,线程中断!

    是的,我们在代码中使用了实例方法isInterrupted判断线程是否已被中断,如果被中断将跳出循环以此结束线程。综合所述,可以简单总结一下中断两种情况:

    • 一种是当线程处于阻塞状态或者试图执行一个阻塞操作时,我们可以使用实例方法interrupt()进行线程中断,执行中断操作后将会抛出interruptException异常(该异常必须捕捉无法向外抛出)并将中断状态复位;
    • 另外一种是当线程处于运行状态时,我们也可调用实例方法interrupt()进行线程中断,但同时必须手动判断中断状态,并编写中断线程的代码(其实就是结束run方法体的代码)。有时我们在编码时可能需要兼顾以上两种情况,那么就可以如下编写:
      package com.dxz.synchronize;
      
      import java.util.concurrent.TimeUnit;
      
      public class InterruputThread3 {
          public static void main(String[] args) throws InterruptedException {
              Thread t1 = new Thread() {
                  @Override
                  public void run() {
                      try {
                          // 判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
                          while (!Thread.interrupted()) {
                              System.out.println("服务中...");
                              TimeUnit.SECONDS.sleep(2);
                          }
                      } catch (InterruptedException e) {
                          System.out.println("中断");
                          // 中断状态被复位
                          System.out.println("interrupt:" + this.isInterrupted());
                      }
                  }
              };
              t1.start();
              TimeUnit.SECONDS.sleep(2);
              t1.interrupt();
          }
      }

    结果:

    服务中...
    服务中...
    中断
    interrupt:false

    中断与synchronized

    事实上线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用,也就是对于synchronized来说,如果一个线程在等待锁,那么结果只有两种,要么它获得这把锁继续执行,要么它就保存等待,即使调用中断线程的方法,也不会生效。演示代码如下

    package com.dxz.synchronize;
    
    import java.util.concurrent.TimeUnit;
    
    public class SynchronizedBlocked implements Runnable {
    
        public synchronized void f() {
            System.out.println("Trying to call f()");
            while (true) // Never releases lock
                Thread.yield();
        }
    
        /**
         * 在构造器中创建新线程并启动获取对象锁
         */
        public SynchronizedBlocked() {
            // 该线程已持有当前实例锁
            new Thread() {
                public void run() {
                    f(); // Lock acquired by this thread
                }
            }.start();
        }
    
        public void run() {
            // 中断判断
            while (true) {
                if (Thread.interrupted()) {
                    System.out.println("中断线程!!");
                    break;
                } else {
                    f();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            SynchronizedBlocked sync = new SynchronizedBlocked();
            Thread t = new Thread(sync);
            // 启动后调用f()方法,无法获取当前实例锁处于等待状态
            t.start();
            TimeUnit.SECONDS.sleep(1);
            // 中断线程,无法生效
            t.interrupt();
        }
    }

    结果:

    Trying to call f()

    我们在SynchronizedBlocked构造函数中创建一个新线程并启动获取调用f()获取到当前实例锁,由于SynchronizedBlocked自身也是线程,启动后在其run方法中也调用了f(),但由于对象锁被其他线程占用,导致t线程只能等到锁,此时我们调用了t.interrupt();但并不能中断线程。

    等待唤醒机制与synchronized

    所谓等待唤醒机制本篇主要指的是notify/notifyAll和wait方法,在使用这3个方法时,必须处于synchronized代码块或者synchronized方法中,否则就会抛出IllegalMonitorStateException异常,这是因为调用这几个方法前必须拿到当前对象的监视器monitor对象,也就是说notify/notifyAll和wait方法依赖于monitor对象,在前面的分析中,我们知道monitor 存在于对象头的Mark Word 中(存储monitor引用指针),而synchronized关键字可以获取 monitor ,这也就是为什么notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法调用的原因。

    synchronized (obj) {
           obj.wait();
           obj.notify();
           obj.notifyAll();         
     }

    需要特别理解的一点是,与sleep方法不同的是wait方法调用完成后,线程将被暂停,但wait方法将会释放当前持有的监视器锁(monitor),直到有线程调用notify/notifyAll方法后方能继续执行,而sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后,并不会马上释放监视器锁,而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。

    转自:

    http://blog.csdn.net/javazejian/article/details/72828483?locationNum=5&fps=1

  • 相关阅读:
    过滤指定目录下指定后缀名文件
    Oracle 存储过程创建表
    编码测试之控制条件筛选心得——AE二次开发篇
    log4j配置祥解 (转)
    手机浏览器的viewport(视觉窗口)
    git 常用技巧
    添加eclipse的字体样式
    如何检测android 文件签名成功(转帖)
    javascript 解析json
    身份证正则表达式
  • 原文地址:https://www.cnblogs.com/duanxz/p/4494420.html
Copyright © 2011-2022 走看看