分析JVM源码之Thread.interrupt系统级别线程打断

@Test

public void interruptedTest() throws InterruptedException {

     Thread sleep = new Thread(() -> {

         try {

             log.info( "sleep thread start" );

             TimeUnit.SECONDS.sleep( 1 );

             log.info( "sleep thread end" );

         } catch (InterruptedException e) {

             log.info( "sleep thread interrupted" );

         }

     }, "sleep_thread" );

     sleep.start();

     TimeUnit.MILLISECONDS.sleep( 100 );

     log.info( "ready to interrupt sleep" );

     sleep.interrupt();

}

@Test

public void normalTest() throws InterruptedException {

     Thread normal = new Thread(() -> {

         log.info( "normal thread start" );

         int i = 0 ;

         while ( true ) {

             i++;

         }

     }, "normal_thread" );

     normal.start();

     TimeUnit.MILLISECONDS.sleep( 100 );

     log.info( "ready to interrupt normal" );

     normal.interrupt();

}

public void interrupt() {

     if ( this != Thread.currentThread())

         checkAccess();

     synchronized (blockerLock) {

         Interruptible b = blocker;

         if (b != null ) {

             //打断的主要方法，该方法的主要作用是设置一个打断标记

             interrupt0();

             b.interrupt( this );

             return ;

         }

     }

     interrupt0();

}

private native void interrupt0();

static JNINativeMethod methods[] = {

     ...

     { "interrupt0" ,       "()V" ,        ( void *)&JVM_Interrupt}

     ...

};

JVM_ENTRY( void , JVM_Interrupt(JNIEnv* env, jobject jthread))

   JVMWrapper( "JVM_Interrupt" );

   ...

   if (thr != NULL) {

     //执行线程打断操作

     Thread::interrupt(thr);

   }

JVM_END

void Thread::interrupt(Thread* thread) {

   //执行os层面的打断

   os::interrupt(thread);

}

void os::interrupt(Thread* thread ) {

   ...

   //获得c++线程对应的系统线程

   OSThread* osthread = thread ->osthread();

   //如果系统线程的打断标记是false，意味着还未被打断

   if (!osthread->interrupted()) {

     //将系统线程的打断标记设为true

     osthread->set_interrupted( true );

     //这个涉及到内存屏障，本文不展开

     OrderAccess::fence();

     //这里获取一个_SleepEvent，并调用其unpark()方法

     ParkEvent * const slp = thread ->_SleepEvent ;

     if (slp != NULL) slp->unpark() ;

   }

   //这里依据JSR166标准，即使打断标记为true，依然要调用下面的2个unpark

   if ( thread ->is_Java_thread())

     //如果是一个java线程，这里获取一个parker对象，并调用其unpark()方法

     ((JavaThread*) thread )->parker()->unpark();

   ParkEvent * ev = thread ->_ParkEvent ;

   //这里获取一个_ParkEvent，并调用其unpark()方法

   if (ev != NULL) ev->unpark() ;

}

ParkEvent * _ParkEvent;    // for synchronized()

ParkEvent * _SleepEvent;   // for Thread.sleep

class ParkEvent : public os::PlatformEvent {

   ...

}

class PlatformEvent : public CHeapObj<mtInternal> {

  private :

   ...

   pthread_mutex_t _mutex[1];

   pthread_cond_t  _cond[1];

   ...

   void park();

   void unpark();

   int   park(jlong millis); // relative timed-wait only

   ...

};

void os::PlatformEvent::park() {

     ...

     //锁住信号量

     int status = pthread_mutex_lock(_mutex);

     while (_Event < 0) {

       //释放信号量，并在条件变量上等待

       status = pthread_cond_wait(_cond, _mutex);

     }

     //释放信号量

     status = pthread_mutex_unlock(_mutex);

}

synchronize(obj){

   obj.wait();

}

ReentrantLock lock = new ReentrantLock();

Condition condition = lock.newCondition();

lock.lock();

condition.wait();

lock.unlock();

void os::PlatformEvent::unpark() {

   ...

   if (AnyWaiters != 0) {

     //唤醒条件变量

     status = pthread_cond_signal(_cond);

   }

   ...

}

public :

   Parker*     parker() { return _parker; }

class Parker : public os::PlatformParker {

     pthread_mutex_t _mutex[1];

     pthread_cond_t  _cond[2]; // one for relative times and one for abs.

}

void Parker::park( bool isAbsolute, jlong time ) {

   ...

   if ( time == 0) {

     //这里是直接长时间等待

     _cur_index = REL_INDEX;

     status = pthread_cond_wait(&_cond[_cur_index], _mutex);

   } else {

     //这里会根据时间是否是绝对时间，分别等待在不同的条件上

     _cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;

     status = pthread_cond_timedwait(&_cond[_cur_index], _mutex, &absTime);

   }

   ...

}

void Parker::unpark() {

   int status = pthread_mutex_lock(_mutex);

   ...

   //因为在等待的时候会有2个等待对象，所以需要先获取正确的索引

   int index = _cur_index;

   ...

   status = pthread_mutex_unlock(_mutex);

   if (s < 1 && index != -1) {

     //唤醒线程

     status = pthread_cond_signal(&_cond[index]);

   }

   ...

}

import java.util.concurrent.TimeUnit;

import java.time.LocalDateTime;

public class MyThread {

     static {

         //设置查找路径为当前项目路径

         System.setProperty( "java.library.path" , "." );

         //加载动态库的名称

         System.loadLibrary( "MyThread" );

     }

     public native void startAndPark();

     public native void interrupt();

     public static void main(String[] args) throws InterruptedException {

         MyThread thread = new MyThread();

         //启动线程打印一段文字，并睡眠

         thread.startAndPark();

         //1秒后主线程打断子线程

         TimeUnit.MILLISECONDS.sleep( 1000 );

         System.out.println(LocalDateTime.now() + "：Main---准备打断线程" );

         //打断子线程

         thread.interrupt();

         System.out.println(LocalDateTime.now() + "：Main---打断完成" );

     }

}

#include <pthread.h>

#include <stdio.h>

#include "MyThread.h"

#include "time.h"

pthread_t pid;

pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t  _cond = PTHREAD_COND_INITIALIZER;

//打印时间

void printTime(){

     char strTm[50] = { 0 };

       time_t currentTm;

       time (&currentTm);

       strftime (strTm, sizeof (strTm), "%x %X" , localtime (&currentTm));

       puts (strTm);

}

//子线程执行的方法

void * thread_entity( void * arg){

     printTime();

     printf ( "MyThread---启动\n" );

     printTime();

     printf ( "MyThread---准备休眠\n" );

     //阻塞线程，等待唤醒

     pthread_cond_wait(&_cond, &_mutex);

     printTime();

     printf ( "MyThread---休眠被打断\n" );

}

//对应MyThread中的startAndPark方法

JNIEXPORT void JNICALL Java_MyThread_startAndPark(JNIEnv *env, jobject c1){

     //创建一个子线程

     pthread_create(&pid, NULL, thread_entity, NULL);

}

//对应MyThread中的interrupt方法

JNIEXPORT void JNICALL Java_MyThread_interrupt(JNIEnv *env, jobject c1){

     //唤醒线程

     pthread_cond_signal(&_cond);

}