前言
 
Java 中经常会遇到要获取当前线程的情况，这时一般我们就会通过Thread.currentThread()来获取，接下去就看看执行该语句在 JVM 中做了什么吧。
 
简单例子
 
以下是一个简单的例子，获取当前线程并打印线程名称，输出是”main”，即主线程。
 
public class CurrentThreadTest {

    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
    }

}
 
currentThread方法
 
在 Thread 类中，currentThread是一个静态且本地方法。
 
public static native Thread currentThread();
 
Thread.c
 
Java 层声明的本地方法对应实现在 Thread.c 中，currentThread是一个注册到 JVM 中的方法，它与 JVM 中的JVM_CurrentThread函数绑定了，所以实现逻辑在JVM_CurrentThread函数里。逻辑为： 
 * JVMWrapper("JVM_CurrentThread")用于调试。 
 * 通过thread->threadObj()获取 oop，这里的 thread 是在JNI_ENTRY宏中获取到的，详细情况可参考后面的JNI_ENTRY和JNI_END宏。 
 * 调用JNIHandles::make_local函数
 
#define THD "Ljava/lang/Thread;"

static JNINativeMethod methods[] = {
    ...
    {"currentThread",    "()" THD,     (void *)&JVM_CurrentThread},
    ...
};

JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
  JVMWrapper("JVM_CurrentThread");
  oop jthread = thread->threadObj();
  assert (thread != NULL, "no current thread!");
  return JNIHandles::make_local(env, jthread);
JVM_END
 
make_local函数中主要看thread_from_jni_environment函数，它用于获取当前线程，它的逻辑为JavaThread *thread_from_jni_env = (JavaThread*)((intptr_t)env - in_bytes(jni_environment_offset()));，即直接通过地址偏移来做减法计算得到JavaThread*，这是因为 JavaThread 对象包含了 JNIEnv 对象属性，所以可以通过JNIEnv*与偏移做减法来算出JavaThread*。最后还要检查线程是否已经终止状态，没有终止才返回该线程对象。
 
获取到JavaThread*对象后，分配句柄并将 oop 赋给句柄，并且转成 Java 层的对象 jobject。
 
jobject JNIHandles::make_local(JNIEnv* env, oop obj) {
  if (obj == NULL) {
    return NULL;                
  } else {
    JavaThread* thread = JavaThread::thread_from_jni_environment(env);
    assert(Universe::heap()->is_in_reserved(obj), "sanity check");
    return thread->active_handles()->allocate_handle(obj);
  }
}

static JavaThread* thread_from_jni_environment(JNIEnv* env) {
    JavaThread *thread_from_jni_env = (JavaThread*)((intptr_t)env - in_bytes(jni_environment_offset()));
    if (thread_from_jni_env->is_terminated()) {
      thread_from_jni_env->block_if_vm_exited();
      return NULL;
    } else {
      return thread_from_jni_env;
    }
  }
 
JNI_ENTRY和JNI_END宏
 
这两个宏将共同的部分都抽离出来了。其中JNI_END比较简单，就两个结束大括号。
 
#define JNI_ENTRY(result_type, header)  JNI_ENTRY_NO_PRESERVE(result_type, header)    WeakPreserveExceptionMark __wem(thread);

#define JNI_END } }
 
JNI_ENTRY主要逻辑： 
 * 获取当前执行线程 JavaThread 指针对象。 
 * 创建 ThreadInVMfromNative 对象。 
 * TRACE_CALL ，这里什么都不干。 
 * 创建 HandleMarkCleaner 对象。 
 * 将 thread 赋值给 Exceptions 中的 THREAD。 
 * 校验栈对齐。 
 * 创建 WeakPreserveExceptionMark 对象。
 
#define JNI_ENTRY_NO_PRESERVE(result_type, header)                   \
extern "C" {                                                         \
  result_type JNICALL header {                                       \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
    ThreadInVMfromNative __tiv(thread);                              \
    debug_only(VMNativeEntryWrapper __vew;)                          \
    VM_ENTRY_BASE(result_type, header, thread)

#define VM_ENTRY_BASE(result_type, header, thread)                   \
  TRACE_CALL(result_type, header)                                    \
  HandleMarkCleaner __hm(thread);                                    \
  Thread* THREAD = thread;                                           \
  os::verify_stack_alignment();      
 
————-推荐阅读————
 
我的2017文章汇总——机器学习篇
 
我的2017文章汇总——Java及中间件
 
我的2017文章汇总——深度学习篇
 
我的2017文章汇总——JDK源码篇
 
我的2017文章汇总——自然语言处理篇
 
我的2017文章汇总——Java并发篇
 
 
跟我交流，向我提问：
 
 
公众号的菜单已分为“读书总结”、“分布式”、“机器学习”、“深度学习”、“NLP”、“Java深度”、“Java并发核心”、“JDK源码”、“Tomcat内核”等，可能有一款适合你的胃口。
 
为什么写《Tomcat内核设计剖析》
 
欢迎关注：
 

这篇学习关于Thread类的两个方法，第一个是获取当前线程对象，返回的是一个Thread对象。第二个方法是我们自动化中经常使用的，线程休眠。
 
1.currentThread()
 
获取的是当前线程对象，是对象不是对象名称，如果要获取名称，需要对象.getName()实现。
 
package thread;

public class Demo5_Thread {

	public static void main(String[] args) {
		
		new Thread() {
			public void run() {
				System.out.println(this.getName() +": aaaaa");
			}
		}.start();
		
		new Thread(new Runnable() {
			
			public void run() {
				System.out.println(Thread.currentThread().getName()+": bbbb");
			}
		}).start();
		
		//main方法打印线程名称
		System.out.println(Thread.currentThread().getName());
	}

}
 
运行结果：
 
Thread-0: aaaaa
main
Thread-1: bbbb
 
这个打印结果，也说明了，多线程中,main方法本身就是一个单独线程执行，而且执行顺序并不会像代码写的从上往下的顺序。
 
2.线程休眠
 
休眠就是让线程停顿下来，支持不同时间单位的中断。这个方法是Thread.sleep(xxx毫秒)。我们写自动化脚本经常需要用到它。
 
package thread;

public class Demo5_Thread {

	public static void main(String[] args) throws InterruptedException {
		
		new Thread() {
			public void run() {
				for(int i = 0; i< 10; i ++) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
					System.out.println(this.getName() +": aaaaa");
				}
				
			}
		}.start();
		
		new Thread(new Runnable() {
			
			public void run() {
				for(int i = 0; i< 10; i ++) {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+": bbbb");
				}
				
			}
		}).start();
		
		//main方法打印线程名称
		System.out.println(Thread.currentThread().getName());
	}

}
 
运行之后，可以看到间隔一秒输出一个。

import threading
import time


def test1():
    for i in range(5):
        print("子线程1：%s" % i)
        time.sleep(1)
    # 如果创建Thread时执行的函数，函数运行结束意味着 这个子线程结束...


def test2():
    for i in range(5):
        print("子线程2：%s" % i)
        time.sleep(1)


if __name__ == '__main__':
    # 在调用thread之前打印当前线程信息
    print(threading.enumerate())
    # 创建线程
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)

    t1.start()
    t2.start()

    # 查看线程数量
    thread_num = len(threading.enumerate())
    print("主线程：线程数量是%d" % thread_num)
    # 输出所有线程名字
    print(str(threading.enumerate()))
    print("主线程：主线程结束")

功能代码:
 printf("ThreadID: %d\n", GetCurrentThreadId()); //经测试这个函数速度更快
 printf("ThreadID: %d\n", (*(uint32_t*)&std::this_thread::get_id());
 
我们要获取线程id，那么必然要用到get_id这个函数，那么我们看看这个函数返回的是什么。
 
 看到了吗， _Thrd_id()其实是一个uint32_t类型的返回值，但是却被转换成了thread::id类型，
 那么我们再来看看thread::id这个类里面有什么吧。
 .看到了，里面就只有一个成员变量， 那就是类型为uint32_t的_Id， 那么我相信这时候大部分学过C++的同学都知道了吧， 那就是获取类成员地址在类中的偏移量 &类实例+偏移量 = 我们想要的成员地址， 因为thread::id类只有一个成员变量， 那么偏移量就为0， 所以就直接通过&std::this_thread::get_id()就拿到了我们想要的id类成员地址， 这时候再在前面加上*(uint32_t*)通过转指针解引用我们就拿到了想要的线程id, 是不是很简单？
 本来之前在网上想看看别人怎么获取线程ID的， 结果一堆输入输出，强转… ，一行代码搞定的事非要
 弄个三四行还要用上各种平时不怎么用的类这些， 然后自己看了下thread::id的代码，现在发上来。
 
另外推荐GetCurrentThreadId()这个函数 可以直接获取当前线程id