java本质_线程的本质（Java 层实现）

关于上下文请看 线程本质，下面我们直接进入正题。

使用

先看看我们平时使用的方式，使用线程常见的代码如下：

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

while (true) {

// 哒哒哒哒

}

}

});

thread.start();

然后我们知道里边的代码不会阻塞当前的执行流，而是新开一个异步线程去执行 while 循环，但是，为什么呢？

为什么就不会阻塞 UI 线程？

以及它到底是如何调度系统资源的？

或者直接一点，这货到底是怎么实现的？

代码

带着上边的问题，我们先来看一下 java 端的代码Thread.java，Java 层的线程实现自然是最简单的，搞 Android 或者 java 的对这个应该也很熟悉。这里我们简要介绍一下：

为了方便，我们先把 Runnable 贴一下，因为 Thread implements Runnable。

// 就是一个接口定义了一个 run 方法，这里不多说

public interface Runnable {

public abstract void run();

}

然后我们在把 Thread 的几个主要属性及函数列一下(不关主线的代码就都删掉了)：

package java.lang;

public class Thread implements Runnable {

// 先执行 native 函数来做一些注册相关的东西

private static native void registerNatives();

static {

registerNatives();

}

private Runnable target;

// 优先级

public final static int MIN_PRIORITY = 1;

public final static int NORM_PRIORITY = 5;

public final static int MAX_PRIORITY = 10;

private int priority;

public final void setPriority(int newPriority) {

...

setPriority0(priority = newPriority);

}

public final int getPriority() {

return priority;

}

// 以下几个变量会在 native 层 classloader 时被调用，这里不做过多解释(这里其实也是应该删掉的)

private Thread threadQ;

private long eetop;

private boolean single_step;

private boolean stillborn = false;

private long nativeParkEventPointer;

// ThreadGroup 相关

private ThreadGroup group;

public final ThreadGroup getThreadGroup() {

return group;

}

public static int activeCount() {

return currentThread().getThreadGroup().activeCount();

}

public static int enumerate(Thread tarray[]) {

return currentThread().getThreadGroup().enumerate(tarray);

}

// name 相关(就是日志中打印出来的线程名字)，当线程初始化时，会根据 threadInitNumber 来自动生成线程名字

private char name[];

private static int threadInitNumber;

private static synchronized int nextThreadNum() {

return threadInitNumber++;

}

public final void setName(String name) {

...

this.name = name.toCharArray();

}

public final String getName() {

return String.valueOf(name);

}

// tid 相关(线程 id)，通过 threadSeqNumber 的累加来赋值 tid(与 native 层的线程 id 没有一毛钱关系)

private long tid;

private static long threadSeqNumber;

private static synchronized long nextThreadID() {

return ++threadSeqNumber;

}

public long getId() {

return tid;

}

// ThreadLocal，主要用来存储线程独有的变量，如果想了解的话可以参考 [ThreadLocal 框架](http://www.jianshu.com/p/e34ec28bf7a4)

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

//线程状态

private int threadStatus = 0;

public enum State {

NEW,

RUNNABLE,

BLOCKED,

WAITING,

TIMED_WAITING,

TERMINATED;

}

public State getState() {

return sun.misc.VM.toThreadState(threadStatus);

}

// 线程休眠

public static void sleep(long millis, int nanos) throws InterruptedException {

。。。

sleep(millis);

}

// 初始化

private void init(ThreadGroup g, Runnable target, String name,

long stackSize) {

Thread parent = currentThread();

...

this.group = g;

this.priority = parent.getPriority();

this.name = name.toCharArray();

this.target = target;

setPriority(priority);

....

tid = nextThreadID();

}

// 构造函数，有多个，为了方便展示框架，这里只贴了一个

public Thread(Runnable target) {

init(null, target, "Thread-" + nextThreadNum(), 0);

}

// 开始真正执行此线程

public synchronized void start() {

...

start0();

...

}

// 没什么好说的，直接执行了 Runnable 的 run 函数

public void run() {

if (target != null) {

target.run();

}

}

// 判断当前线程是否中断

public void interrupt() {

...

interrupt0();

}

public static boolean interrupted() {

return currentThread().isInterrupted(true);

}

public boolean isInterrupted() {

return isInterrupted(false);

}

// 阻塞调用此函数的线程，直到 join 归属的 Thread 实例执行完。核心就是执行了 wait，而 wait 这个函数其实也是 native 实现

public final synchronized void join(long millis) throws InterruptedException {

long base = System.currentTimeMillis();

long now = 0;

...

if (millis == 0) {

while (isAlive()) {

wait(0);

}

} else {

while (isAlive()) {

long delay = millis - now;

if (delay <= 0) {

break;

}

wait(delay);

now = System.currentTimeMillis() - base;

}

}

}

// native 相关函数

public static native boolean holdsLock(Object obj);

private native static StackTraceElement[][] dumpThreads(Thread[] threads);

private native static Thread[] getThreads();

public static native Thread currentThread();

public static native void yield();

public static native void sleep(long millis) throws InterruptedException;

private native boolean isInterrupted(boolean ClearInterrupted);

public final native boolean isAlive();

private native void start0();

private native void setPriority0(int newPriority);

private native void stop0(Object o);

private native void suspend0();

private native void resume0();

private native void interrupt0();

}

总结

不多说，其实 Java 层的线程就是一层皮，没有什么实质性的逻辑，没有任何申请内存等相关的逻辑，就连 tid 都是根据 ++threadInitNumber 叠加出来的，与 native 层的完全没有关系。

我们发现我们上边的疑惑仍然没有得到解答，那我们接下来就看一下 native 层的实现。