一、线程的状态
在正式学习Thread类中的具体方法之前，我们先来了解一下线程有哪些状态，这个将会有助于对Thread类中的方法的理解。
线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建（new）、就绪（runnable）、运行（running）、阻塞（blocked）、time waiting、waiting、消亡（dead）。
当需要新起一个线程来执行某个子任务时，就创建了一个线程。但是线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件（比如内存资源，在前面的JVM内存区域划分一篇博文中知道程序计数器、Java栈、本地方法都是线程私有的，所以需要为线程分配一定的内存空间），只有线程运行需要的所有条件满足了，才进入就绪状态。
当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其它的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。
线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行），用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。
当由于突然中断或者子任务执行完毕，线程就会被消亡。
下面这幅图描述了线程从创建到消亡之间的状态：
在有些教程上讲blocked、waiting、time waiting统称为阻塞状态，这个也是可以的，只不过这里我想将线程的状态和Java中的方法调用联系起来，所以将waiting和time waiting两个状态分离出来。
二、上下文切换
对于单核CPU来说（对于多核CPU，此处就理解为一个核），CPU在一个时刻只能运行一个线程，当在运行一个线程的过程中转去运行另一个线程，这个叫做线程上下文切换。
由于可能当前线程的任务并没有执行完毕，所以在切换时需要保存线程的运行状态，以便下次重新切换回来时能够继续切换到之前的状态运行。举个简单的例子：比如一个线程A正在读取一个文件的内容，正读到文件的一半，此时需要暂停线程A，转去执行线程B，当再次切换回来执行线程A的时候，我们不希望线程A又从文件的开头来读取。
因此需要记录线程A的运行状态，那么会记录哪些数据呢？因为下次恢复时需要知道在这之前当前线程已经执行到哪条指令了，所以需要记录程序计数器的值，另外比如说线程正在进行某个计算的时候被挂起，那么下次继续执行的时候，需要知道之前挂起时变量的值是多少，因此需要记录CPU寄存器的状态。所以一般来说，线程上下文切换过程中会记录程序计数器、CPU寄存器状态等数据。
说简单点的：对于线程的上下文切换实际上就是存储和恢复CPU状态的过程，它使得线程执行能够从中断点恢复执行。
虽然多线程可以使得任务执行的效率得到提升，但是由于在线程切换时同样会带来一定的开销代价，并且多个线程会导致系统资源占用的增加，所以在进行多线程编程时要注意这些因素。
三、Thread类中的方法
通过查看java.lang.Thread类的源码可知：
Thread类实现了Runnable接口，在Thread类中，有一些比较关键的属性，比如name是表示Thread的名字，可以通过Thread类的构造器的参数来指定线程名字，priority表示线程的优先级（最大值为10，最小值为1，默认值为5），daemon表示线程是否为守护线程，target表示要执行的任务。
下面是Thread类中常用的方法：
1）start方法
start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。
2）run方法
run()方法是不需要用户来调用的，通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。
3）sleep方法
sleep方法有两个重载版本：
sleep(long millis) // 参数为毫秒 sleep(long millis,int nanoseconds) // 第一个参数为毫秒，第二个参数为纳秒
sleep相当于让线程睡眠，交出CPU，让CPU去执行其它的任务。
但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程有对某个对象的锁，则即使使用sleep方法，其它线程也无法访问这个对象。看下面这个例子就清楚了：
1 package com.meng.javalanguage.thread.test; 2 3 import java.io.IOException; 4 5 6 /* 使用sleep方法让线程睡眠，但sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁， 7 * 则即使调用sleep方法，其它线程也无法访问这个对象*/ 8 public class MyThreadTest { 9 10 private int i = 10; 11 private Object object = new Object(); 12 13 public static void main(String[] agrs) throws IOException { 14 MyThreadTest mtTest = new MyThreadTest(); 15 MyThread thread1 = mtTest.new MyThread(); 16 MyThread thread2 = mtTest.new MyThread(); 17 18 thread1.start(); 19 thread2.start(); 20 21 22 } 23 24 class MyThread extends Thread { 25 26 @Override 27 public void run() { 28 synchronized (object) { 29 i++; 30 System.out.println("i:" + i); 31 try { 32 System.out.println("线程" + Thread.currentThread().getName() + "进入睡眠状态"); 33 Thread.currentThread().sleep(10000); 34 }catch(InterruptedException e) { 35 //TODO:handle exception 36 } 37 38 System.out.println("线程" + Thread.currentThread().getName() + "睡眠结束"); 39 i++; 40 System.out.println("i:" + i); 41 } 42 } 43 } 44 }
输出结果：
从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行。
注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其它的任务。所以说调用sleep方法相当于让线程进入阻塞状态。
4）yield方法
调用yield方法会让当前线程交出CPU权限，让CPU去执行其它的线程。它跟sleep方法类型，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。例子如下：
1 package com.meng.javalanguage.thread.test; 2 3 import java.io.IOException; 4 5 6 public class MyThreadTest { 7 8 private int i = 10; 9 private Object object = new Object(); 10 11 public static void main(String[] agrs) throws IOException { 12 MyThreadTest mtTest = new MyThreadTest(); 13 MyThread thread1 = mtTest.new MyThread(); 14 MyThread thread2 = mtTest.new MyThread(); 15 16 thread1.start(); 17 thread2.start(); 18 19 20 } 21 22 class MyThread extends Thread { 23 24 @Override 25 public void run() { 26 synchronized (object) { 27 i++; 28 System.out.println("i:" + i); 29 // try { 30 System.out.println("线程" + Thread.currentThread().getName() + "进入睡眠状态"); 31 Thread.currentThread().yield(); 32 // }catch(InterruptedException e) { 33 //TODO:handle exception 34 // } 35 36 System.out.println("线程" + Thread.currentThread().getName() + "睡眠结束"); 37 i++; 38 System.out.println("i:" + i); 39 } 40 } 41 } 42 }
输出结果：
注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
5）join方法
join方法有三个重载版本：
1 join() 2 join(long millis) // 参数为毫秒 3 join(long millis,int nanoseconds) // 第一个参数为毫秒，第二个参数为纳秒
假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。
看下面一个例子：
1 /* 假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者 2 * 等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕， 3 * 如果调用的是指定了时间参数的join方法，则等待一定的事件。*/ 4 public class MyThreadTest { 5 6 public static void main(String[] args) throws IOException{ 7 System.out.println("进入线程" + Thread.currentThread().getName()); 8 MyThreadTest mtTest = new MyThreadTest(); 9 MyThread thread1 = mtTest.new MyThread(); 10 thread1.start(); 11 12 try{ 13 System.out.println("线程" + Thread.currentThread().getName() + "等待"); 14 thread1.join(); 15 System.out.println("线程" + Thread.currentThread().getName() + "继续执行"); 16 }catch(InterruptedException e) { 17 //TODO Auto-generated catch block 18 e.printStackTrace(); 19 } 20 } 21 22 class MyThread extends Thread { 23 24 @Override 25 public void run() { 26 System.out.println("进入线程" + Thread.currentThread().getName()); 27 try { 28 Thread.currentThread().sleep(5000); 29 }catch(InterruptedException e) { 30 //TODO: handle exception 31 } 32 33 System.out.println("线程" + Thread.currentThread().getName() + "执行完毕"); 34 } 35 } 36 }
输出结果：
可以看出，当调用thread1.join()方法后，main线程会进入等待，然后等待thread1执行完之后再继续执行。实际上调用join方法是调用了Object的wait方法，这个可以通过查看源码得知。
wait方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。
由于wait方法会让线程释放对象锁，所以join方法同样会让线程释放对一个对象持有的锁。
6）interrupt方法
interrupt，顾名思义，即中断的意思。单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就是说，它可以用来中断一个正处于阻塞状态的线程；另外，通过interrupt()方法和isInterrupted()方法来停止正在运行的线程。
下面看一个例子：
1 package com.meng.javalanguage.thread.test; 2 3 import java.io.IOException; 4 5 6 /* 使用interrupt方法来终端一个正处于阻塞状态的线程*/ 7 public class MyThreadTest { 8 9 public static void main(String[] args) throws IOException { 10 11 MyThreadTest mtTest = new MyThreadTest(); 12 MyThread thread = mtTest.new MyThread(); 13 thread.start(); 14 15 try { 16 Thread.currentThread().sleep(2000); 17 }catch(InterruptedException e) { 18 //TODO:handle exception 19 } 20 21 thread.interrupt(); 22 } 23 24 class MyThread extends Thread { 25 26 @Override 27 public void run() { 28 try { 29 System.out.println("进入睡眠状态"); 30 Thread.currentThread().sleep(10000); 31 System.out.println("睡眠完毕"); 32 }catch(InterruptedException e) { 33 System.out.println("得到中断异常"); 34 } 35 36 System.out.println("run方法执行完毕"); 37 } 38 } 39 }
输出结果：
从这里可以看出，通过interrupt方法可以中断处于阻塞状态的线程。那么能不能中断处于非阻塞状态的线程呢？看下面这个例子：
1 package com.meng.javalanguage.thread.test; 2 3 import java.io.IOException; 4 5 6 /* interrupt方法不能中断处于非阻塞状态的线程*/ 7 public class MyThreadTest { 8 9 public static void main(String[] args) throws IOException { 10 MyThreadTest mtTest = new MyThreadTest(); 11 MyThread thread = mtTest.new MyThread(); 12 13 thread.start(); 14 try { 15 Thread.currentThread().sleep(2000); 16 }catch(InterruptedException e) { 17 e.printStackTrace(); 18 } 19 20 thread.interrupt(); 21 } 22 23 24 class MyThread extends Thread { 25 26 @Override 27 public void run() { 28 int i = 0; 29 while(i < Integer.MAX_VALUE) { 30 System.out.println(i + " while循环"); 31 i++; 32 } 33 } 34 } 35 }
运行该程序会发现，while循环会一直运行知道变量i的值超出Integer.MAX_VALUE。所以说直接调用interrupt方法不能中断正在运行中的线程。
但是如果配合isInterrupted()能够中断正在运行的线程，因为调用interrupt方法相当于将中断标志位置为true，那么可以通过调用isInterrupted()判断中断标志是否被置位来中断线程的执行。比如下面这段代码：
1 /* interrupt方法不能中断处于非阻塞状态的线程 2 * 可以配合isInterrupted()判断中断标志是否被置位来中断线程的执行*/ 3 public class MyThreadTest { 4 5 public static void main(String[] args) throws IOException { 6 MyThreadTest mtTest = new MyThreadTest(); 7 MyThread thread = mtTest.new MyThread(); 8 9 thread.start(); 10 try { 11 Thread.currentThread().sleep(2000); 12 }catch(InterruptedException e) { 13 e.printStackTrace(); 14 } 15 16 thread.interrupt(); 17 } 18 19 20 class MyThread extends Thread { 21 22 @Override 23 public void run() { 24 int i = 0; 25 while(!isInterrupted() && i < Integer.MAX_VALUE) { 26 System.out.println(i + " while循环"); 27 i++; 28 } 29 30 System.out.println("线程被中断."); 31 } 32 } 33 }
运行会发现，打印若干个值之后，while循环就停止打印了。
但是一般情况下，不建议通过这种方式来中断线程，一般会在MyThread类中增加一个属性isStop来标志是否结束while循环，然后再在while循环中判断isStop的值。
1 class MyThread extends Thread{ 2 private volatile boolean isStop = false; 3 @Override 4 public void run() { 5 int i = 0; 6 while(!isStop){ 7 i++; 8 } 9 } 10 11 public void setStop(boolean stop){ 12 this.isStop = stop; 13 } 14 }
那么就可以在外面通过调用setStop方法来终止while循环。
7）stop方法
stop方法已经是一个废弃的方法，它是一个不安全的方法。因为调用stop方法会直接终止run方法的调用，并且会抛出一个ThreadDeath错误，如果线程持有某个对象锁的话，会完全释放锁，导致对象的状态不一致。所以stop方法基本不会被用到。
8）destroy方法
destroy方法也是废弃的方法。基本不会被使用到。
以下是关系到线程属性的几个方法：
1）getId
用来得到线程ID
2）getName和setName
用来得到或者设置线程名称。
3）getPriority和setPriority
用来获取和设置线程优先级。
4）setDaemon和isDaemon
用来设置线程是否称为守护线程和判断线程是否是守护线程。
守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。
Thread类有一个比较常用的静态方法currentThread()用来获取当前线程。
在上面已经说到了Thread类中的大部分方法，那么Thread类中的方法调用到底会引起线程状态发生怎样的变化呢？下面一幅图就是在上面的图上进行改进而来的：
转载自《Java并发编程：Thread类的使用》