盘一盘 Thread源码
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
继承关系图
线程的创建方式有很多种。常用的有：继承Thread()，重写该类的run()方法；实现Runnable接口，并重写该接口的run()方法。
其实Thread类本身也是实现了Runnable接口，而run()方法最先是在Runnable接口中定义的方法。
主要属性
// 线程的名称 private volatile char name[]; // 线程的优先级 private int priority; // 是否是单步执行 private boolean single_step; // 是否是守护线程 private boolean daemon = false; // JVM虚拟机的状态 private boolean stillborn = false; // 将会被执行的 Runnable private Runnable target; // 当前线程的组 private ThreadGroup group; // 当前线程的上下文 private ClassLoader contextClassLoader; // 当前线程继承的访问控制权限 private AccessControlContext inheritedAccessControlContext; // 默认线程的自动编号 private static int threadInitNumber; // 得到下个thread ID private static synchronized int nextThreadNum() { return threadInitNumber++; } // 与当前线程有关的ThreadLocal值 ThreadLocal.ThreadLocalMap threadLocals = null; // 与当前线程相关的InheritableThreadLocal值。 ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; // 该线程请求的堆栈大小 默认一般为空 JVM自行分配 private long stackSize; // 当前线程终止后，JVM的私有状态 private long nativeParkEventPointer; // 当前线程的专属ID private long tid; // 用来生成 thread ID private static long threadSeqNumber; // 线程状态，0代表线程未启动 Runable private volatile int threadStatus = 0; // 中断阻塞器：当线程发生IO中断时，需要在线程被设置为中断状态后调用该对象的interrupt方法 volatile Object parkBlocker; // 阻塞器锁，主要用于线程中断 private volatile Interruptible blocker; private final Object blockerLock = new Object(); // 阻断锁 void blockedOn(Interruptible b) { synchronized (blockerLock) { blocker = b; } } // 线程优先级 最低优先级 public final static int MIN_PRIORITY = 1; // 线程优先级 默认优先级 public final static int NORM_PRIORITY = 5; // 线程优先级 最高优先级 public final static int MAX_PRIORITY = 10;
构造方法
我们平时惯用new Thread()方法去创建一个线程，实际上线程初始化的过程中已经完成了很多默认的配置
// init方法相关参数 // g 线程组 // target 实现 Runnable接口类对象，就是调用 run方法的目标对象 // name 线程名称 // stackSize 栈的大小 该值对JVM而言只是一个建议，JVM会动态选择更合适的值 // acc 访问控制权限 private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) { if (name == null) { throw new NullPointerException("name cannot be null"); } this.name = name.toCharArray(); // 设置当前线程为该线程的父线程 Thread parent = currentThread(); // 获取系统的security SecurityManager security = System.getSecurityManager(); // 没有指定线程组的话，创建的所有线程属于相同的线程组。 if (g == null) { // 先将secuity的线程组赋给新线程的线程组 if (security != null) { g = security.getThreadGroup(); } // 如果还是为空，则设为父线程的线程组 if (g == null) { g = parent.getThreadGroup(); } } // 检查当前线程是否有修改权限 g.checkAccess(); // 授权 if (security != null) { if (isCCLOverridden(getClass())) { security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION); } } g.addUnstarted(); // 设置守护线程、优先等级 this.group = g; this.daemon = parent.isDaemon(); this.priority = parent.getPriority(); if (security == null || isCCLOverridden(parent.getClass())) this.contextClassLoader = parent.getContextClassLoader(); else this.contextClassLoader = parent.contextClassLoader; this.inheritedAccessControlContext = acc != null ? acc : AccessController.getContext(); this.target = target; setPriority(priority); if (parent.inheritableThreadLocals != null) this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); // 分配线程栈的大小 this.stackSize = stackSize; // 分配线程Id ThreadID是由JVM分配的，并不是系统的真正线程ID tid = nextThreadID(); } private void init(ThreadGroup g, Runnable target, String name, long stackSize) { init(g, target, name, stackSize, null); } public Thread() { init(null, null, "Thread-" + nextThreadNum(), 0); } public Thread(Runnable target) { init(null, target, "Thread-" + nextThreadNum(), 0); } Thread(Runnable target, AccessControlContext acc) { init(null, target, "Thread-" + nextThreadNum(), 0, acc); } public Thread(ThreadGroup group, Runnable target) { init(group, target, "Thread-" + nextThreadNum(), 0); } public Thread(String name) { init(null, null, name, 0); } public Thread(ThreadGroup group, String name) { init(group, null, name, 0); } public Thread(Runnable target, String name) { init(null, target, name, 0); } public Thread(ThreadGroup group, Runnable target, String name) { init(group, target, name, 0); } public Thread(ThreadGroup group, Runnable target, String name, long stackSize) { init(group, target, name, stackSize); }
native方法
// 获得当前线程 public static native Thread currentThread(); // 使当前线程从 运行状态Running 变为 就绪状态 Runnable public static native void yield(); // 使当前线程进入休眠状态 public static native void sleep(long millis) throws InterruptedException; // 使线程进入就绪状态 Runnable private native void start0(); // 判断线程是否为中断状态 private native boolean isInterrupted(boolean ClearInterrupted); // 判断线程是否存活 public final native boolean isAlive(); // 获取所有线程列表 private native static StackTraceElement[][] dumpThreads(Thread[] threads); private native static Thread[] getThreads(); // 设置线程优先等级 private native void setPriority0(int newPriority); // 停止线程 该方法已被弃用 private native void stop0(Object o); // 线程暂停 private native void suspend0(); // 线程继续执行 private native void resume0(); // 线程中断 private native void interrupt0(); // 设置线程名 private native void setNativeName(String name);
这里不得不说和线程相关的几个Object Native方法。
// 随机唤醒在此对象监视器（锁）上等待的单个线程。 public final native void notify(); // 唤醒所有等待在该对象上的线程。 public final native void notifyAll(); // 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法 public final void wait() throws InterruptedException { wait(0); } // 超时等待一段时间，这里的参数是毫秒，也就是等待长达n毫秒，如果没有通知就超时返回。 public final native void wait(long timeout) throws InterruptedException;
我最开始有些疑惑，为什么wait(),notify(),notifyAll()用来操作线程会定义在Object类中？
不妨我们先做一个假设：将wait、notify和线程队列都放到Thread中，那么在wait、notify的调度过程中必然要求某个Thread知道其他所有Thread的信息，显然是不合理的。
而放到对象中，让对象维护所有竞争锁线程的队列，各个线程无必然联系。
关键方法
start() 启动线程
public synchronized void start() { // 判断线程状态是否启动，不允许同一线程启动2次！ if (threadStatus != 0) throw new IllegalThreadStateException(); // 向线程组中添加当前线程 group.add(this); // 使线程进入就绪状态 Runnable boolean started = false; try { start0(); started = true; } finally { try { // 若线程启动失败,则通知该线程组，回滚线程组状态 // 该线程被视为线程组的未启动成员，并允许后续尝试启动该线程。 if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */ } } }
checkAccess() 检查当前线程是否有修改权限，该方法在线程状态变更前多次被调用
public final void checkAccess() { SecurityManager security = System.getSecurityManager(); if (security != null) { // 通过Java安全管理器检查当前线程是否有修改权限 security.checkAccess(this); } }
run() 使线程从就绪状态 Runnable转化为运行状态 Running -todo线程启动过程中由start到run的过程非常复杂。
public void run() { // 调用 run方法的目标对象 if (target != null) { target.run(); } }
exit() 该方法 run方法执行完成后调用，在线程结束退出之前进行清理工作。
private void exit() { // 释放资源 if (group != null) { group.threadTerminated(this); group = null; } target = null; threadLocals = null; inheritableThreadLocals = null; inheritedAccessControlContext = null; blocker = null; uncaughtExceptionHandler = null; }
stop() stop方法是不安全的，它会立即停止线程执行，线程的后续执行不连贯。可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。故被标记为@Deprecated
@Deprecated public final void stop() { SecurityManager security = System.getSecurityManager(); if (security != null) { checkAccess(); if (this != Thread.currentThread()) { security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION); } } if (threadStatus != 0) { resume(); // Wake up thread if it was suspended; no-op otherwise } stop0(new ThreadDeath()); }
interrupt() 中断线程
public void interrupt() { if (this != Thread.currentThread()) checkAccess(); synchronized (blockerLock) { Interruptible b = blocker; if (b != null) { interrupt0(); // Just to set the interrupt flag b.interrupt(this); return; } } interrupt0(); }
setPriority()、getPriority() 设置、获取线程优先级
public final void setPriority(int newPriority) { ThreadGroup g; checkAccess(); // 线程优先级范围仅分 1~10 级 if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) { throw new IllegalArgumentException(); } if((g = getThreadGroup()) != null) { if (newPriority > g.getMaxPriority()) { newPriority = g.getMaxPriority(); } setPriority0(priority = newPriority); } } public final int getPriority() { return priority; }
join() 在当前线程中调用另一个线程的join()方法，使当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。
public final void join() throws InterruptedException { join(0); } public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }
setDaemon() 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
public final void setDaemon(boolean on) { checkAccess(); // 该方法必须在启动线程前调用 if (isAlive()) { throw new IllegalThreadStateException(); } daemon = on; }
