在java中，谈到线程，必然少不了Thread类。线程是比进程更轻量级的调度执行单位。为什么用线程？通过使用线程，可以把操作系统进程的资源分配和执行调度分开，各个线程既可以共享进程资源（内存地址、文件I/O等），又可以独立调度（线程是CPU调度的基本单位）。
 
主流操作系统（Windows, Linux）都提供了线程的实现，Java则提供了在不同硬件和操作系统下对线程的统一处理，Thread类则是Java中线程的实现。
 
Java线程的实现方式：
 
Java线程使用操作系统的内核线程实现，内核线程（Kernel-Level Thread, KLT）是直接由操作系统内核（Kernel，内核）支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器（Scheduler）对线程进行调度，并负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身（孙悟空的分身术？），这样操作系统就有能力同时处理多件事情，支持多线程的内核就叫做多线程内核（Muti-Threads Kernel)。
 
Java程序如何使用内核线程：
 
程序一般通过使用内核线程的高级接口-----轻量级进程（Light Weight Process, LWP），也就是我们通常意义上的线程。每个LWP都由一个内核线程支持。也就是说任何时候使用Java代码创建线程，调用Thread.start()的时候，都是通过LWP接口创建了KLT内核线程，然后通过OS的Thread Scheduler对内核线程进行调度分配CPU。线程模型如下图所示：
 
 
内核线程的优点：
 
（1）每一个内核线程都是独立的轻量级进程，一个线程的阻塞不会影响整个进程的工作。
 
内核线程的缺点：
 
（1）由于是基于内核线程实现，各种线程的操作，如创建、析构、中断、休眠和同步，都需要系统调度（频繁从用户态切换进内核态），而系统调度的代价相对较高；
 
（2）占用内核资源，同时轻量级进程的数量有限。
 
Thread线程运行在Java Virtual Machine中，要理解Java中线程的运行方式，得先了解Java内存模型。Java虚拟机规范中定义了一种Java内存模型（Java Memory Model）来屏蔽各种硬件和操作系统的内存访问差异，以实现Java程序在各种平台下都能达到一致的内存访问效果（一次编译，随处运行得以实现的基础）。
 
主内存与工作内存：
 
JAVA内存模型规定了所有的变量都存储在主内存（Main Memory）中。所有的线程都有自己的工作内存，工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中执行，而不能直接读写主内存中的变量。同时，线程之间也无法读写各自的工作内存。关系图：
 
 
线程状态转换图：
 
 
Thread#yield()：
 
执行此方法会向系统线程调度器（Schelduler）发出一个暗示，告诉其当前JAVA线程打算放弃对CPU的使用，但该暗示，有可能被调度器忽略。使用该方法，可以防止线程对CPU的过度使用，提高系统性能。
 
Thread#sleep(time)或Thread.sleep(time, nanos)：
 
使当前线程进入休眠阶段，状态变为：TIME_WAITING
 
Thread.interrupt()：
 
中断当前线程的执行，允许当前线程对自身进行中断，否则将会校验调用方线程是否有对该线程的权限。
 
如果当前线程因被调用Object#wait(),Object#wait(long, int), 或者线程本身的join(), join(long),sleep()处于阻塞状态中，此时调用interrupt方法会使抛出InterruptedException，而且线程的阻塞状态将会被清除。
 
Thread#interrupted()，返回true或者false：
 
查看当前线程是否处于中断状态，这个方法比较特殊之处在于，如果调用成功，会将当前线程的interrupt status清除。所以如果连续2次调用该方法，第二次将返回false。
 
Thread.isInterrupted()，返回true或者false：
 
与上面方法相同的地方在于，该方法返回当前线程的中断状态。不同的地方在于，它不会清除当前线程的interrupt status状态。
 
Thread#join()，Thread#join(time)：
 
A线程调用B线程的join()方法，将会使A等待B执行，直到B线程终止。如果传入time参数，将会使A等待B执行time的时间，如果time时间到达，将会切换进A线程，继续执行A线程。

概述
 
Java所有多线程的实现，均通过封装Thread类实现，所以深入Thread类，对深入理解java多线程很有必要
 
 
构造函数：
 
Thread的构造函数，采用缺省的方式实现：
 
//传入Runnable接口实现
Thread(Runnable target)
//传入Runnable接口实现,传入线程名
Thread(Runnable target, String name) 
//设置当前线程用户组
Thread(ThreadGroup group, Runnable target)
//设置用户组，传入线程名
Thread(ThreadGroup group, Runnable target, String name)
//设置用户组，传入线程名，设置当前线程栈大小
Thread(ThreadGroup group, Runnable target, String name, long stackSize) 
 
Thread类构造函数源码分析：
 1.线程默认名称生产规则：
 
// 当前缺省线程名："Thread-" + nextThreadNum()
public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
---
// nextThreadNum 同步方法，线程安全，不会出现重复的threadInitNumber
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
    return threadInitNumber++;
}
 
2.线程私有化实现
 
/**
     * 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.
     * @param acc the AccessControlContext to inherit, or
     *            AccessController.getContext() if null
     * @param inheritThreadLocals if {@code true}, inherit initial values for
     *            inheritable thread-locals from the constructing thread
     */
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        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;
        /* 设置当前线程是否为守护线程，默认是和当前类的ThreadGroup设置相
        * 同。如果是守护线程的话，当前线程结束会随着主线程的退出而退出。
        *jvm退出的标识是，当前系统没有活跃的非守护线程。
        */
        this.daemon = parent.isDaemon();
        /*设置的线程的访问权限默认为当前ThreadGroup权限*/
        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 (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        /*设置指定的栈大小，如果未指定大小，将在jvm 初始化参数中声明：Xss参数进行指定*/
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }
 
 
start()方法源码分析：
 
/*  导致此线程开始执行; Java Virtual Machine调用此线程的run方法。
    结果是两个线程同时运行：当前线程（从调用返回到start方法）和另一个线程（执行其run方法）。
    不止一次启动线程永远不合法。
    特别是，一旦完成执行，线程可能无法重新启动。
    @exception IllegalThreadStateException如果线程已经启动。
    @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 */
            }
        }
    }
 
 
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) {
        // 如果millis == 0 线程将一直等待下去
            while (isAlive()) {
                wait(0);
            }
        } else {
            // 指定了millis ，等待指定时间以后，会break当前线程
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
 
 
Thread 内部枚举 State：
 
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中的一个线程
         * state正在Java虚拟机中执行但它可能正在执行
         * 等待操作系统中的其他资源
         * 如处理器。
         */
        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;
    }
 
线程六种状态之间的关系，其中进入阻塞状态是java虚拟机自定义状态，通常都是遇到获取当前锁，synchronize代码同步块
 
 
 
run()方法源码：
 
/*Thread类重写了Runnable接口的run()方法。
 该run()方法首先判断当前是否有Runnable的实现target存在。
 如果存在就执行target.run()
*/
 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 
run 方法的实现，是通过Java静态代理的方式实现的。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lm7AJmJe-1577089548842)(http://i.imgur.com/oh3VMNs.gif)]
 

方法摘要 
 static int activeCount() 
           返回当前线程的线程组中活动线程的数目。 
  void checkAccess() 
           判定当前运行的线程是否有权修改该线程。 
  int countStackFrames() 
           已过时。 该调用的定义依赖于 suspend()，但它遭到了反对。此外，该调用的结果从来都不是意义明确的。 
 static Thread currentThread() 
           返回对当前正在执行的线程对象的引用。 
  void destroy() 
           已过时。 该方法最初用于破坏该线程，但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以 suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
 static void dumpStack() 
           将当前线程的堆栈跟踪打印至标准错误流。 
 static int enumerate(Thread[] tarray) 
           将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。 
 static Map<Thread,StackTraceElement[]> getAllStackTraces() 
           返回所有活动线程的堆栈跟踪的一个映射。 
  ClassLoader getContextClassLoader() 
           返回该线程的上下文 ClassLoader。 
 static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 
           返回线程由于未捕获到异常而突然终止时调用的默认处理程序。 
  long getId() 
           返回该线程的标识符。 
  String getName() 
           返回该线程的名称。 
  int getPriority() 
           返回线程的优先级。 
  StackTraceElement[] getStackTrace() 
           返回一个表示该线程堆栈转储的堆栈跟踪元素数组。 
  Thread.State getState() 
           返回该线程的状态。 
  ThreadGroup getThreadGroup() 
           返回该线程所属的线程组。 
  Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() 
           返回该线程由于未捕获到异常而突然终止时调用的处理程序。 
 static boolean holdsLock(Object obj) 
           当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。 
  void interrupt() 
           中断线程。 
 static boolean interrupted() 
           测试当前线程是否已经中断。 
  boolean isAlive() 
           测试线程是否处于活动状态。 
  boolean isDaemon() 
           测试该线程是否为守护线程。 
  boolean isInterrupted() 
           测试线程是否已经中断。 
  void join() 
           等待该线程终止。 
  void join(long millis) 
           等待该线程终止的时间最长为 millis 毫秒。 
  void join(long millis, int nanos) 
           等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 
  void resume() 
           已过时。 该方法只与 suspend() 一起使用，但 suspend() 已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
  void run() 
           如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 
  void setContextClassLoader(ClassLoader cl) 
           设置该线程的上下文 ClassLoader。 
  void setDaemon(boolean on) 
           将该线程标记为守护线程或用户线程。 
 static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
           设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。 
  void setName(String name) 
           改变线程名称，使之与参数 name 相同。 
  void setPriority(int newPriority) 
           更改线程的优先级。 
  void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) 
           设置该线程由于未捕获到异常而突然终止时调用的处理程序。 
 static void sleep(long millis) 
           在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 
 static void sleep(long millis, int nanos) 
           在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 
  void start() 
           使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 
  void stop() 
           已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用 interrupt 方法来中断该等待。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
  void stop(Throwable obj) 
           已过时。 该方法具有固有的不安全性。有关详细信息，请参阅 stop()。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
  void suspend() 
           已过时。 该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 resume 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。 
  String toString() 
           返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 
 static void yield() 
           暂停当前正在执行的线程对象，并执行其他线程。 

 单核cpu运行多线程时底层实现原理是多个线程间切换，由于cpu的处理速度很快，看上去像多个线程同时运行。那么我们如何实现让线程T1，T2，T3，在T1执行完成后才执行T2，T2执行完成后才执行T3，也就是线程的串行化，通过Thread类的join方法就可以实现。
 

 
 
 

 join方法：将该线程加入当前线程，当前线程等待加入线程执行完成才继续执行。
 

 例子：
 

 public class ThreadJoinTest implements Runnable {
 
 
 

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

  Thread thread = new Thread(new ThreadJoinTest());
 

  thread.start();
 

  thread.join();
 

  System.out.println("主线程结束");
 

  }
 
 
 
 
 

  @Override
 

  public void run() {
 

  System.out.println("子线程开始");
 

  for(int i = 0; i < 5; i++) {
 

  try {
 

  Thread.sleep(1000);
 

  } catch (InterruptedException e) {
 

  e.printStackTrace();
 

  }
 

  System.out.println(i);
 

  }
 

  System.out.println("子线程结束");
 

  }
 

  }
 

  执行结果：
 
 
 
 
 
 

  
 
 
 

 
 

 join(long  millis)方法：将该线程加班当前线程，当前线程等待加入线程millis时间，当达到millis时间后不管加入线程是否完成，当前线程都继续执行，若加入线程在小于millis时间执行完成，则当前线程等待时间等于加入线程的执行时间。
 

 例子：
 

 public class ThreadJoinTest implements Runnable {
 
 
 

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

  Thread thread = new Thread(new ThreadJoinTest());
 

  thread.start();
 

  thread.join(2000);
 

  System.out.println("主线程结束");
 

  }
 
 
 
 
 

  @Override
 

  public void run() {
 

  System.out.println("子线程开始");
 

  for(int i = 0; i < 5; i++) {
 

  try {
 

  Thread.sleep(1000);
 

  } catch (InterruptedException e) {
 

  e.printStackTrace();
 

  }
 

  System.out.println(i);
 

  }
 

  System.out.println("子线程结束");
 

  }
 

  }
 

 执行结果：