java中断线程

java中断线程

  • 1 线程中断
  • 2 原理分析
    • 2.1 线程底层源码入口
    • 2.2 断源码分析
    • 2.3 中断状态查询
  • 3 Thread.sleep/Object.join/Object.wait 对中断的处理
  • 4 Thread.sleep 源码解析
  • 5 究竟该如何停止线程
  • 5 分析

1 线程中断

在线程里使用sleep、wait、join等方法,当线程被中断时,中断状态位会被重置为false,并且抛出InterruptedException异常(这也是为什么我们第一个例子里thread.isInterrupted()为false的原因)
在线程里使用nio InterruptibleChannel接口时,当线程被中断时,中断状态位会被重置为true,并且抛出ClosedByInterruptException异常
在线程里使用nio Selector时,当线程被中断时,中断状态位会被重置为true
如不属于上述条件,则中断状态位会被重置为true(对应我们上面说的没有阻塞的情况)

thread.isInterrupted() 和 Thread.interrupted()区别
thread.isInterrupted()是对象方法,表示thread的中断状态。Thread.interrupted()是静态方法,表示当前线程的中断状态

总之
1、线程正在执行sleep、join、wait等方法,此时线程处在WAITING/TIMED_WAITING状态,当执行thread.interrupt(),那么会抛出InterruptedException异常,线程中断标记位为false,线程停止运行;
2、线程处在RUNNABLE状态,当执行thread.interrupt(),不会抛出异常,线程中断标记位为true,线程未停止运行;
3、如果线程处在BLOCKED(Synchronized争抢锁)状态,当执行thread.interrupt(),不会抛出异常,线程中断标记位为true,线程未停止运行(这点也说明了Synchronized不可打断)

2 原理分析

2.1 线程底层源码入口

Java 层的Thread
以Thread.java里的方法Thread.interrupt()为例,最终调用了interrupt0()方法:

private native void interrupt0();
可以看出,是native方法,接下来看看怎么找到其JNI实现。

JNI 入口
在Thread.c里定义了JNI 方法:

interrupt0()方法对应JVM_Interrupt()函数。
在jvm.cpp里:

#jvm.cpp
JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
JVMWrapper(“JVM_Interrupt”);

oop java_thread = JNIHandles::resolve_non_null(jthread);
MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
if (thr != NULL) {
//调用Thread.cpp里的函数
Thread::interrupt(thr);
}
JVM_END
继续跟进Thread.cpp:

#Thread.cpp
void Thread::interrupt(Thread* thread) {
//调用os里的函数
os::interrupt(thread);
}
最终调用了os里的函数。

2.2 断源码分析

中断源码分析
入口找到了,接着继续深入分析。上面分析到了os::interrupt(thread),os是区分系统的,此处以Linux系统为例:

#os_linux.cpp
void os::interrupt(Thread* thread) {
  ...
  OSThread* osthread = thread->osthread();

  //中断标记位没有设置
  if (!osthread->interrupted()) {
    //则设置中断标记位为true
    osthread->set_interrupted(true);
    OrderAccess::fence();
    ParkEvent * const slp = thread->_SleepEvent ;
    //唤醒线程,对应sleep挂起
    if (slp != NULL) slp->unpark() ;
  }

  //唤醒线程,对应wait/join 操作挂起等
  if (thread->is_Java_thread())
    ((JavaThread*)thread)->parker()->unpark();

  //唤醒线程,对应synchronized 获取锁挂起
  ParkEvent * ev = thread->_ParkEvent ;
  if (ev != NULL) ev->unpark() ;
}

显然,在Java 层调用Thread.interrupt()方法,最终底层完成了两件事:

1、将中断标记位设置为true。
2、将挂起的线程唤醒。
java中断线程_第1张图片

2.3 中断状态查询

Java 层的Thread.java里提供了两个方法来查询中断标记位的值,分别是:

#Thread.java
    //成员方法
    public boolean isInterrupted() {
        return isInterrupted(false);
    }

    //静态方法
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }

无论是成员方法还是静态方法,最终都调用了Thread.isInterrupted(xx)方法:

#Thread.java
    //ClearInterrupted 表示是否清空中断标记位
    private native boolean isInterrupted(boolean ClearInterrupted);

可以看出:

1、成员方法isInterrupted()没有清空中断标记位。
2、静态方法interrupted()清空了中断标记位。

继续跟进isInterrupted(xx)方法,由上面跟踪的入口经验最终有如下代码:

#Thread.cpp
  bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
     return os::is_interrupted(thread, clear_interrupted);
   }

#os_linux.cpp
  bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
    OSThread* osthread = thread->osthread();
    //查询当前中断值
    bool interrupted = osthread->interrupted();

    if (interrupted && clear_interrupted) {
      //如果参数clear_interrupted 为true,表示要清空标记位
      //则设置标记位为false
      osthread->set_interrupted(false);
  }

  //返回查询到的中断标记位的值
  return interrupted;
}

因此,Thread.isInterrupted(xx)方法的作用是:

1、查询当前线程的中断标记位的值。
2、根据参数决定是否重置中断标记。

而Thread.isInterrupted(xx) 是私有方法,因此Thread.java 对外提供了两种方法:Thread.isInterrupted()(成员方法)和Thread.interrupted(静态方法)。

3 Thread.sleep/Object.join/Object.wait 对中断的处理

中断线程Demo

 @Test
    public void testInterrupt(){
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("t1 is alive " + System.currentTimeMillis());
                }
            }
        });

        t1.start();

        try {
            //保证t1运行一会
            Thread.sleep(2000);
            //中断t1
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        while (true) {
            System.out.println("t1 interrupt status:" + t1.isInterrupted() + " t1 isAlive:" + t1.isAlive() + " " +  System.currentTimeMillis());
        }
    }

该Demo的目的是:

1、先开启线程t1,让t1不断循环打印时间。
2、在另一个线程(主线程)中断t1,并不断查询t1中断标记位的值。

如果没有分析上面的中断原理,你可能会认为t1应该被中断退出了循环。实际上从打印结果可知,t1的中断标记位被设置为true,然而t1并没有退出循环。这结果符合我们的原理分析,因为中断线程的操作底层只做了两件事:设置中断标记位和唤醒线程。
在上面的例子里,t1并没有被挂起,因此唤醒线程没啥实际意义。
总而言之:

"中断线程"这个词听起来比较霸气,让人误以为就是让一个线程停止运行。实际上线程的停止与否并不是它控制的,而是线程执行过程中主
动退出或是有异常抛出。

将上面的Demo稍加修改如下:

@Test
    public void testInterrupt1(){
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("t1 is alive " + System.currentTimeMillis());
                        //睡眠一会再执行
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    System.out.println("t1 catch exception:" + e.getMessage());
                }
            }
        });

        t1.start();

        try {
            //保证t1运行一会
            Thread.sleep(2000);
            //中断t1
            t1.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        while (true) {
            System.out.println("t1 interrupt status:" + t1.isInterrupted() + " t1 isAlive:" + t1.isAlive() + " " +  System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

相比上一个Demo,仅仅是在t1里增加1s的睡眠时间,打印结果如下:
java中断线程_第2张图片
可以看出,t1被中断后因为抛出了异常而退出了循环,其中断标记位为false,线程已经停止了运行。

4 Thread.sleep 源码解析

通过比对上面两个Demo可知,引起结果不同是因为增加了Thread.sleep(xx)方法,因此来看看它内部到底做了什么。

#jvm.cpp
JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))
  JVMWrapper("JVM_Sleep");
  //在睡眠之前先检查是否已经发生了中断,若是则抛出中断异常
  if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
    THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
  }
  ...

  if (millis == 0) {
    ...
  } else {
    ThreadState old_state = thread->osthread()->get_state();
    thread->osthread()->set_state(SLEEPING);
    if (os::sleep(thread, millis, true) == OS_INTRPT) {
      //睡眠结束后,判断是否已经发生了中断,若是则抛出中断异常
        THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
      }
    }
    thread->osthread()->set_state(old_state);
  }
  ...
JVM_END

#os_linux.cpp
int os::sleep(Thread* thread, jlong millis, bool interruptible) {
  assert(thread == Thread::current(),  "thread consistency check");

  //_SleepEvent 是ParkEvent类型
  ParkEvent * const slp = thread->_SleepEvent ;
  ...
  //interruptible 表示是否支持中断,默认支持
  if (interruptible) {
    ...
    for (;;) {
      //此处是死循环,退出依靠return或者break
      if (os::is_interrupted(thread, true)) {
        //再次判断是否已经发生中断,若是则返回OS_INTRPT
        //该值在外层判断
        return OS_INTRPT;
      }

      //时间耗尽,则退出
      if(millis <= 0) {
        return OS_OK;
      }
      ...
      {
        //挂起线程
        slp->park(millis);
        //线程被唤醒后继续循环
      }
    }
  } else {
    for (;;) {
      ...
      //时间耗尽,则退出
      if(millis <= 0) break ;

      prevtime = newtime;
      slp->park(millis);
    }
    return OS_OK ;
  }
}

可以看出,Thread.sleep(xx)方法作用如下:

1、线程挂起一定的时间,时间到达后继续执行循环。
2、interruptible==true场景下,在循环里判断是否发生了中断,若是,则抛出中断异常。

再来分析上面的Demo:

1、线程调用Thread.sleep(xx)进行睡眠,此时线程被挂起。
2、外部调用Thread.interrupt()中断该线程,此时中断标记位值为true。
3、线程被唤醒,唤醒后判断是否发生了中断(通过中断标记位),若是则抛出异常。

虽然Thread.interrupt()没有直接停止线程,但是可以利用中断标记位来查看是否发生过中断的动作,根据这个动作来决定是否停止线程的执行。
而对于Thread.sleep(xx)来说,作为一个公共方法,当检测到中断时,抛出中断异常让外部处理。

以上分析了Thread.sleep(xx)原理,还有个小细节:
当外界调用Thread.interrupt()并捕获了中断异常的时候,此时线程的中断标记位的值位false,这个在哪修改的呢?
判断中断标记时使用了如下代码:

os::is_interrupted(thread, true)

第二个参数表示重置当前中断标记位的值,该函数上面已经分析过。

调用Object.join/Object.wait 挂起线程,此时线程若被中断,表现与Thread.sleep差不多,此处就不再展开分析了。

5 究竟该如何停止线程

还是来看Demo:

public class TestThread {
    static volatile boolean isCancelThread = false;
    public static void main(String args[]) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(!isCancelThread || !Thread.currentThread().isInterrupted()) {
                    try {
                        doSomething1();
                        doSomething2();
                    } catch (Exception e) {
                        if (e instanceof InterruptedException) {
                            isCancelThread = true;
                        }
                    }
                }
            }
        });

        t1.start();

        //另一个线程两种方式停止线程
        //1、设置isCancelThread = true
        //2、调用t1.interrupt()
    }

    private static void doSomething1() {
        //具体逻辑
    }

    private static void doSomething2() {
        //具体逻辑
    }
}

来分析Demo逻辑:
doSomething1() 、doSomething2() 可能是自己写的方法,也可能是其它人提供的方法,它们内部可能会使得线程阻塞。

第一:
外部通过设置isCancelThread 来标记是否让线程停止运行。这种写法有个缺陷,若是线程在调用doSomething1() 或doSomething2()时阻塞,那么将不会立即检测isCancelThread的值,也即是不能立即停止线程。

第二
针对doSomething1() 或doSomething2()可能阻塞的问题,外部通过使用
Thread.interrupt()中断线程,此时需要捕获异常,捕获到了中断异常意味着可以停止线程运行了。
当然,如果你不想额外使用isCancelThread标记,可以直接判断中断标记位:Thread.currentThread().isInterrupted(),此时Demo再改改:

    while(!Thread.currentThread().isInterrupted()) {
        try {
            doSomething1();
            doSomething2();
        } catch (Exception e) {
            if (e instanceof InterruptedException) {
                Thread.currentThread().interrupt();
            }
        }
    }

为什么要额外在catch里增加中断动作呢?原因是中断时可能会遇到sleep/wait/join 等方法将中断标记位的值置为false,此处再次中断是为了让while感知到中断已经发生过了,从而退出循环。

5 分析

来看个Demo,Thread处在RUNNABLE时调用interrupt()中断:

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    doSomething();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();


        Thread.sleep(2000);

        t1.interrupt();
        System.out.println("main thread interrupt Thread t1");

    }

    private static void doSomething() throws InterruptedException{
        while(true) {
            System.out.println("thread state:" + Thread.currentThread().getState() + " " + System.currentTimeMillis());
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException();
            }
        }
    }
}

再来看来看个Demo,Thread处在WAITING时调用interrupt()中断:

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    doSomething();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        long count = 100000;
        while(count >= 0) {
            System.out.println("thread state:" + t1.getState() + " " + System.currentTimeMillis());
            count--;
        }

        t1.interrupt();
        System.out.println("main thread interrupt Thread t1");
        while (true) {
            Thread.sleep(1000);
            System.out.println("after interrupt thread state:" + t1.getState() + " " + System.currentTimeMillis());
        }

    }

    private static void doSomething() throws InterruptedException{
        while(true) {
            LockSupport.park();
        }
    }
}

问题的根源是:

线程停止与否要看线程执行体里的代码(方法/代码块)有没有检测中断,并且检测之后是否有处理中断(抛出异常/return 出正常流程)。
因此更严谨的说法是:线程是否能被中断取决于它是否检测并处理了中断状态。
这在AQS里实现可中断锁/不可中断锁时会充分体现。

你可能感兴趣的:(java,java,开发语言)