背景

无论从哪里来看现在web的开发中线程都被各种框架封装的很完善了，

无论选用rpc或者http请求中现在的线程（或者说线程池）都是框架在管理。

那么这是否说明程序员不需要相关线程的知识呢？

当然不是！

基础知识

关于线程通常实现多线程的方法

源码

那么惯例我们先来看一下结构图

类图

构造函数

/**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (null, null, gname)}, where {@code gname} is a newly generated  * name. Automatically generated names are of the form  * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.  */ public Thread() {     init(null, null, "Thread-" + nextThreadNum(), 0); }   /**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (null, target, gname)}, where {@code gname} is a newly generated  * name. Automatically generated names are of the form  * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.  *  * @param  target  *         the object whose {@code run} method is invoked when this thread  *         is started. If {@code null}, this classes {@code run} method does  *         nothing.  */ public Thread(Runnable target) {     init(null, target, "Thread-" + nextThreadNum(), 0); }   /**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (group, target, gname)} ,where {@code gname} is a newly generated  * name. Automatically generated names are of the form  * {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.  *  * @param  group  *         the thread group. If {@code null} and there is a security  *         manager, the group is determined by {@linkplain  *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.  *         If there is not a security manager or {@code  *         SecurityManager.getThreadGroup()} returns {@code null}, the group  *         is set to the current thread's thread group.  *  * @param  target  *         the object whose {@code run} method is invoked when this thread  *         is started. If {@code null}, this thread's run method is invoked.  *  * @throws  SecurityException  *          if the current thread cannot create a thread in the specified  *          thread group  */ public Thread(ThreadGroup group, Runnable target) {     init(group, target, "Thread-" + nextThreadNum(), 0); }   /**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (null, null, name)}.  *  * @param   name  *          the name of the new thread  */ public Thread(String name) {     init(null, null, name, 0); }   /**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (group, null, name)}.  *  * @param  group  *         the thread group. If {@code null} and there is a security  *         manager, the group is determined by {@linkplain  *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.  *         If there is not a security manager or {@code  *         SecurityManager.getThreadGroup()} returns {@code null}, the group  *         is set to the current thread's thread group.  *  * @param  name  *         the name of the new thread  *  * @throws  SecurityException  *          if the current thread cannot create a thread in the specified  *          thread group  */ public Thread(ThreadGroup group, String name) {     init(group, null, name, 0); }   /**  * Allocates a new {@code Thread} object. This constructor has the same  * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}  * {@code (null, target, name)}.  *  * @param  target  *         the object whose {@code run} method is invoked when this thread  *         is started. If {@code null}, this thread's run method is invoked.  *  * @param  name  *         the name of the new thread  */ public Thread(Runnable target, String name) {     init(null, target, name, 0); }   /**  * Allocates a new {@code Thread} object so that it has {@code target}  * as its run object, has the specified {@code name} as its name,  * and belongs to the thread group referred to by {@code group}.  *  * <p>If there is a security manager, its  * {@link SecurityManager#checkAccess(ThreadGroup) checkAccess}  * method is invoked with the ThreadGroup as its argument.  *  * <p>In addition, its {@code checkPermission} method is invoked with  * the {@code RuntimePermission("enableContextClassLoaderOverride")}  * permission when invoked directly or indirectly by the constructor  * of a subclass which overrides the {@code getContextClassLoader}  * or {@code setContextClassLoader} methods.  *  * <p>The priority of the newly created thread is set equal to the  * priority of the thread creating it, that is, the currently running  * thread. The method {@linkplain #setPriority setPriority} may be  * used to change the priority to a new value.  *  * <p>The newly created thread is initially marked as being a daemon  * thread if and only if the thread creating it is currently marked  * as a daemon thread. The method {@linkplain #setDaemon setDaemon}  * may be used to change whether or not a thread is a daemon.  *  * @param  group  *         the thread group. If {@code null} and there is a security  *         manager, the group is determined by {@linkplain  *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.  *         If there is not a security manager or {@code  *         SecurityManager.getThreadGroup()} returns {@code null}, the group  *         is set to the current thread's thread group.  *  * @param  target  *         the object whose {@code run} method is invoked when this thread  *         is started. If {@code null}, this thread's run method is invoked.  *  * @param  name  *         the name of the new thread  *  * @throws  SecurityException  *          if the current thread cannot create a thread in the specified  *          thread group or cannot override the context class loader methods.  */ public Thread(ThreadGroup group, Runnable target, String name) {     init(group, target, name, 0); }   /**  * Allocates a new {@code Thread} object so that it has {@code target}  * as its run object, has the specified {@code name} as its name,  * and belongs to the thread group referred to by {@code group}, and has  * the specified <i>stack size</i>.  *  * <p>This constructor is identical to {@link  * #Thread(ThreadGroup,Runnable,String)} with the exception of the fact  * that it allows the thread stack size to be specified.  The stack size  * is the approximate number of bytes of address space that the virtual  * machine is to allocate for this thread's stack.  <b>The effect of the  * {@code stackSize} parameter, if any, is highly platform dependent.</b>  *  * <p>On some platforms, specifying a higher value for the  * {@code stackSize} parameter may allow a thread to achieve greater  * recursion depth before throwing a {@link StackOverflowError}.  * Similarly, specifying a lower value may allow a greater number of  * threads to exist concurrently without throwing an {@link  * OutOfMemoryError} (or other internal error).  The details of  * the relationship between the value of the <tt>stackSize</tt> parameter  * and the maximum recursion depth and concurrency level are  * platform-dependent.  <b>On some platforms, the value of the  * {@code stackSize} parameter may have no effect whatsoever.</b>  *  * <p>The virtual machine is free to treat the {@code stackSize}  * parameter as a suggestion.  If the specified value is unreasonably low  * for the platform, the virtual machine may instead use some  * platform-specific minimum value; if the specified value is unreasonably  * high, the virtual machine may instead use some platform-specific  * maximum.  Likewise, the virtual machine is free to round the specified  * value up or down as it sees fit (or to ignore it completely).  *  * <p>Specifying a value of zero for the {@code stackSize} parameter will  * cause this constructor to behave exactly like the  * {@code Thread(ThreadGroup, Runnable, String)} constructor.  *  * <p><i>Due to the platform-dependent nature of the behavior of this  * constructor, extreme care should be exercised in its use.  * The thread stack size necessary to perform a given computation will  * likely vary from one JRE implementation to another.  In light of this  * variation, careful tuning of the stack size parameter may be required,  * and the tuning may need to be repeated for each JRE implementation on  * which an application is to run.</i>  *  * <p>Implementation note: Java platform implementers are encouraged to  * document their implementation's behavior with respect to the  * {@code stackSize} parameter.  *  *  * @param  group  *         the thread group. If {@code null} and there is a security  *         manager, the group is determined by {@linkplain  *         SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.  *         If there is not a security manager or {@code  *         SecurityManager.getThreadGroup()} returns {@code null}, the group  *         is set to the current thread's thread group.  *  * @param  target  *         the object whose {@code run} method is invoked when this thread  *         is started. If {@code null}, this thread's run method is invoked.  *  * @param  name  *         the name of the new thread  *  * @param  stackSize  *         the desired stack size for the new thread, or zero to indicate  *         that this parameter is to be ignored.  *  * @throws  SecurityException  *          if the current thread cannot create a thread in the specified  *          thread group  *  * @since 1.4  */ public Thread(ThreadGroup group, Runnable target, String name,               long stackSize) {     init(group, target, name, stackSize); }

我们一般使用Runnable传入 此时调用 此时可以看到传入的默认名称为Thread- XXX

/**  * Initializes a Thread.  *  * @param g the Thread group  * @param target the object whose run() method gets called  * @param name the name of the new Thread  * @param stackSize the desired stack size for the new thread, or  *        zero to indicate that this parameter is to be ignored.  */ private void init(ThreadGroup g, Runnable target, String name,                   long stackSize) {     if (name == null) {         throw new NullPointerException("name cannot be null");     }       Thread parent = currentThread();     SecurityManager security = System.getSecurityManager();     if (g == null) {         /* Determine if it's an applet or not */           /* If there is a security manager, ask the security manager            what to do. */         if (security != null) {             g = security.getThreadGroup();         }           /* If the security doesn't have a strong opinion of the matter            use the parent thread group. */         if (g == null) {             g = parent.getThreadGroup();         }     }       /* checkAccess regardless of whether or not threadgroup is        explicitly passed in. */     g.checkAccess();       /*      * Do we have the required permissions?      */     if (security != null) {         if (isCCLOverridden(getClass())) {             security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);         }     }       g.addUnstarted();       this.group = g;     this.daemon = parent.isDaemon();     this.priority = parent.getPriority();     this.name = name.toCharArray();     if (security == null || isCCLOverridden(parent.getClass()))         this.contextClassLoader = parent.getContextClassLoader();     else         this.contextClassLoader = parent.contextClassLoader;     this.inheritedAccessControlContext = AccessController.getContext();     this.target = target;     setPriority(priority);     if (parent.inheritableThreadLocals != null)         this.inheritableThreadLocals =             ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);     /* Stash the specified stack size in case the VM cares */     this.stackSize = stackSize;       /* Set thread ID */     tid = nextThreadID(); }

当没有设置ThreadGroup是默认将当前线程ThreadGroup取出并将线程放入

同时以parent线程设置相关优先级守护线程等等

注意当传入stackSize为0的时候表示将采用虚拟机默认堆栈size

当然默认size大小可以通过jvm参数xss控制

可以参考R大的知乎

请问 JVM线程的栈在64位Linux操作系统上的默认大小是多少？

注意每个线程的tid会由全局生成

/* For generating thread ID */ private static long threadSeqNumber;     private static synchronized long nextThreadID() {     return ++threadSeqNumber; }

不知道为啥没采用AtomicLong

Start

/**  * Causes this thread to begin execution; the Java Virtual Machine  * calls the <code>run</code> method of this thread.  * <p>  * The result is that two threads are running concurrently: the  * current thread (which returns from the call to the  * <code>start</code> method) and the other thread (which executes its  * <code>run</code> method).  * <p>  * It is never legal to start a thread more than once.  * In particular, a thread may not be restarted once it has completed  * execution.  *  * @exception  IllegalThreadStateException  if the thread was already  *               started.  * @see        #run()  * @see        #stop()  */ public synchronized void start() {     /**      * This method is not invoked for the main method thread or "system"      * group threads created/set up by the VM. Any new functionality added      * to this method in the future may have to also be added to the VM.      *      * A zero status value corresponds to state "NEW".      */     if (threadStatus != 0)         throw new IllegalThreadStateException();       /* Notify the group that this thread is about to be started      * so that it can be added to the group's list of threads      * and the group's unstarted count can be decremented. */     group.add(this);       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 */         }     } }   private native void start0();

大家都知道通过调用thread的start方法可以开启一个线程。那么

start方法首先必然是同步过的否则就可能会出现多个线程开启同一个线程。

当线程start首先判断其state（必须state为NEW才可以开启）换言之线程不可以重复开启

否则抛出异常

此时将对应threadGroup放入该线程对应threadGroup中的unstarted--

通过调用native的start0方法完成线程的启动

我们需要知道的是start0方法将会调到thread的start方法

具体相关的jdk源码可以参考 jdk8u/jdk8u/hotspot: b0f52462883d src/share/vm/prims/jvm.cpp

而具体Thread是如何调用到runnable

/**  * If this thread was constructed using a separate  * <code>Runnable</code> run object, then that  * <code>Runnable</code> object's <code>run</code> method is called;  * otherwise, this method does nothing and returns.  * <p>  * Subclasses of <code>Thread</code> should override this method.  *  * @see     #start()  * @see     #stop()  * @see     #Thread(ThreadGroup, Runnable, String)  */ @Override public void run() {     if (target != null) {         target.run();     } }

因此请注意各位如果继承了Thread并且复写了run方法的开发者请注意此时可能不能再通过传递runnable来完成线程的启动了~

setDaemon

/**  * Marks this thread as either a {@linkplain #isDaemon daemon} thread  * or a user thread. The Java Virtual Machine exits when the only  * threads running are all daemon threads.  *  * <p> This method must be invoked before the thread is started.  *  * @param  on  *         if {@code true}, marks this thread as a daemon thread  *  * @throws  IllegalThreadStateException  *          if this thread is {@linkplain #isAlive alive}  *  * @throws  SecurityException  *          if {@link #checkAccess} determines that the current  *          thread cannot modify this thread  */ public final void setDaemon(boolean on) {     checkAccess();     if (isAlive()) {         throw new IllegalThreadStateException();     }     daemon = on; }

守护线程顾名思义是其他线程的守护者。当jvm中存在的所有线程（用户线程/守护线程）均为守护线程 系统将会退出

守护线程的设置必须在线程开启之前

典型的守护线程比如垃圾回收线程或者Finalizer队列

private static class FinalizerThread extends Thread {     FinalizerThread(ThreadGroup g) {         super(g, "Finalizer");     }     public void run() {         for (;;) {             try {                 Finalizer f = (Finalizer)queue.remove();                 f.runFinalizer();             } catch (InterruptedException x) {                 continue;             }         }     } }   static {     ThreadGroup tg = Thread.currentThread().getThreadGroup();     for (ThreadGroup tgn = tg;          tgn != null;          tg = tgn, tgn = tg.getParent());     Thread finalizer = new FinalizerThread(tg);     finalizer.setPriority(Thread.MAX_PRIORITY - 2);     finalizer.setDaemon(true);     finalizer.start(); }

private static class Daemon extends Thread {     public void run() {         while(true) {             synchronized(GC.lock) {                 long var1 = GC.latencyTarget;                 if (var1 == 9223372036854775807L) {                     GC.daemon = null;                     return;                 }                   long var4 = GC.maxObjectInspectionAge();                 if (var4 >= var1) {                     System.gc();                     var4 = 0L;                 }                   try {                     GC.lock.wait(var1 - var4);                 } catch (InterruptedException var8) {                     ;                 }             }         }     }       private Daemon(ThreadGroup var1) {         super(var1, "GC Daemon");     }       public static void create() {         PrivilegedAction var0 = new PrivilegedAction<Void>() {             public Void run() {                 ThreadGroup var1 = Thread.currentThread().getThreadGroup();                   for(ThreadGroup var2 = var1; var2 != null; var2 = var2.getParent()) {                     var1 = var2;                 }                   GC.Daemon var3 = new GC.Daemon(var1);                 var3.setDaemon(true);                 var3.setPriority(2);                 var3.start();                 GC.daemon = var3;                 return null;             }         };         AccessController.doPrivileged(var0);     } }   private static class LatencyLock {     private LatencyLock() {     } }

interrupt

/**  * Interrupts this thread.  *  * <p> Unless the current thread is interrupting itself, which is  * always permitted, the {@link #checkAccess() checkAccess} method  * of this thread is invoked, which may cause a {@link  * SecurityException} to be thrown.  *  * <p> If this thread is blocked in an invocation of the {@link  * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link  * Object#wait(long, int) wait(long, int)} methods of the {@link Object}  * class, or of the {@link #join()}, {@link #join(long)}, {@link  * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},  * methods of this class, then its interrupt status will be cleared and it  * will receive an {@link InterruptedException}.  *  * <p> If this thread is blocked in an I/O operation upon an {@link  * java.nio.channels.InterruptibleChannel </code>interruptible  * channel<code>} then the channel will be closed, the thread's interrupt  * status will be set, and the thread will receive a {@link  * java.nio.channels.ClosedByInterruptException}.  *  * <p> If this thread is blocked in a {@link java.nio.channels.Selector}  * then the thread's interrupt status will be set and it will return  * immediately from the selection operation, possibly with a non-zero  * value, just as if the selector's {@link  * java.nio.channels.Selector#wakeup wakeup} method were invoked.  *  * <p> If none of the previous conditions hold then this thread's interrupt  * status will be set. </p>  *  * <p> Interrupting a thread that is not alive need not have any effect.  *  * @throws  SecurityException  *          if the current thread cannot modify this thread  *  * @revised 6.0  * @spec JSR-51  */ 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(); }

当一个线程被阻塞在某些方法调用比如object.wait thread.join thread.sleep 等方法时可能收到InterruptedException（换言之这些方法的调用需要捕获）

但是当一个线程处在活动状态时其实调用interrupt并不会导致线程暂停（其实对应调用为stop 目前已经废弃，直接停用对应线程太过暴力）

只是会在对应线程设置一个标记位，通过调用isInterrupted完成判断

/**  * Tests whether this thread has been interrupted.  The <i>interrupted  * status</i> of the thread is unaffected by this method.  *  * <p>A thread interruption ignored because a thread was not alive  * at the time of the interrupt will be reflected by this method  * returning false.  *  * @return  <code>true</code> if this thread has been interrupted;  *          <code>false</code> otherwise.  * @see     #interrupted()  * @revised 6.0  */ public boolean isInterrupted() {     return isInterrupted(false); }

一个较好的方案是

Thread thread = new Thread(() -> {     while (!Thread.interrupted()) {              } }); thread.start();   thread.interrupt();

注意判断用了while做了循环（防止出现中断状态被清除了后再次被设置）

我们调用的是Thread.interrupted的静态方法，表示其针对当前运行线程

/**  * Tests whether the current thread has been interrupted.  The  * <i>interrupted status</i> of the thread is cleared by this method.  In  * other words, if this method were to be called twice in succession, the  * second call would return false (unless the current thread were  * interrupted again, after the first call had cleared its interrupted  * status and before the second call had examined it).  *  * <p>A thread interruption ignored because a thread was not alive  * at the time of the interrupt will be reflected by this method  * returning false.  *  * @return  <code>true</code> if the current thread has been interrupted;  *          <code>false</code> otherwise.  * @see #isInterrupted()  * @revised 6.0  */ public static boolean interrupted() {     return currentThread().isInterrupted(true); }   /**  * Tests whether this thread has been interrupted.  The <i>interrupted  * status</i> of the thread is unaffected by this method.  *  * <p>A thread interruption ignored because a thread was not alive  * at the time of the interrupt will be reflected by this method  * returning false.  *  * @return  <code>true</code> if this thread has been interrupted;  *          <code>false</code> otherwise.  * @see     #interrupted()  * @revised 6.0  */ public boolean isInterrupted() {     return isInterrupted(false); }   /**  * Tests if some Thread has been interrupted.  The interrupted state  * is reset or not based on the value of ClearInterrupted that is  * passed.  */ private native boolean isInterrupted(boolean ClearInterrupted);

可以参考开涛的相关博客 你的JAVA代码响应中断么

join

/**  * Waits at most {@code millis} milliseconds for this thread to  * die. A timeout of {@code 0} means to wait forever.  *  * <p> This implementation uses a loop of {@code this.wait} calls  * conditioned on {@code this.isAlive}. As a thread terminates the  * {@code this.notifyAll} method is invoked. It is recommended that  * applications not use {@code wait}, {@code notify}, or  * {@code notifyAll} on {@code Thread} instances.  *  * @param  millis  *         the time to wait in milliseconds  *  * @throws  IllegalArgumentException  *          if the value of {@code millis} is negative  *  * @throws  InterruptedException  *          if any thread has interrupted the current thread. The  *          <i>interrupted status</i> of the current thread is  *          cleared when this exception is thrown.  */ 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;         }     } }

很明显器调用的是object.wait方法==》注意所有的wait方法都需要先获得monitor（因此必须block在获取监视器，可能也需要消耗时间）从上面可以看出线程未启动是调用join方法也是无效

State

/**  * A thread state.  A thread can be in one of the following states:  * <ul>  * <li>{@link #NEW}<br>  *     A thread that has not yet started is in this state.  *     </li>  * <li>{@link #RUNNABLE}<br>  *     A thread executing in the Java virtual machine is in this state.  *     </li>  * <li>{@link #BLOCKED}<br>  *     A thread that is blocked waiting for a monitor lock  *     is in this state.  *     </li>  * <li>{@link #WAITING}<br>  *     A thread that is waiting indefinitely for another thread to  *     perform a particular action is in this state.  *     </li>  * <li>{@link #TIMED_WAITING}<br>  *     A thread that is waiting for another thread to perform an action  *     for up to a specified waiting time is in this state.  *     </li>  * <li>{@link #TERMINATED}<br>  *     A thread that has exited is in this state.  *     </li>  * </ul>  *  * <p>  * A thread can be in only one state at a given point in time.  * These states are virtual machine states which do not reflect  * any operating system thread states.  *  * @since   1.5  * @see #getState  */ public enum State {     /**      * Thread state for a thread which has not yet started.      */     NEW,       /**      * Thread state for a runnable thread.  A thread in the runnable      * state is executing in the Java virtual machine but it may      * be waiting for other resources from the operating system      * such as processor.      */     RUNNABLE,       /**      * Thread state for a thread blocked waiting for a monitor lock.      * A thread in the blocked state is waiting for a monitor lock      * to enter a synchronized block/method or      * reenter a synchronized block/method after calling      * {@link Object#wait() Object.wait}.      */     BLOCKED,       /**      * Thread state for a waiting thread.      * A thread is in the waiting state due to calling one of the      * following methods:      * <ul>      *   <li>{@link Object#wait() Object.wait} with no timeout</li>      *   <li>{@link #join() Thread.join} with no timeout</li>      *   <li>{@link LockSupport#park() LockSupport.park}</li>      * </ul>      *      * <p>A thread in the waiting state is waiting for another thread to      * perform a particular action.      *      * For example, a thread that has called <tt>Object.wait()</tt>      * on an object is waiting for another thread to call      * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on      * that object. A thread that has called <tt>Thread.join()</tt>      * is waiting for a specified thread to terminate.      */     WAITING,       /**      * Thread state for a waiting thread with a specified waiting time.      * A thread is in the timed waiting state due to calling one of      * the following methods with a specified positive waiting time:      * <ul>      *   <li>{@link #sleep Thread.sleep}</li>      *   <li>{@link Object#wait(long) Object.wait} with timeout</li>      *   <li>{@link #join(long) Thread.join} with timeout</li>      *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>      *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>      * </ul>      */     TIMED_WAITING,       /**      * Thread state for a terminated thread.      * The thread has completed execution.      */     TERMINATED; }   /**  * Returns the state of this thread.  * This method is designed for use in monitoring of the system state,  * not for synchronization control.  *  * @return this thread's state.  * @since 1.5  */ public State getState() {     // get current thread state     return sun.misc.VM.toThreadState(threadStatus); }

1. NEW 表示线程初始化完成 尚未调用过start
2. RUNNABLE 表示线程已经掉用过start之后正在 可能正在运行也可能正在等待其他资源（比如cpu）
3. BLOCKED 表示当前正阻塞在获取监视器，正在等待监视器
4. WAITTING 表示当前线程调用了wait或者join或者LockSupport#park 此时需要其他线程唤醒
5. TIMED_WAITTING  表示当前线程调用了wait(long)或者join(long)或者LockSupport#parkNanos 或者Thread#sleep(long) 等待一段时间过后自己恢复
6. TERMINATED 表示线程已经结束
   参考 http://blog.csdn.net/hangelsing/article/details/44037675

我们可以看看线上的线程表现