一、什么是线程
要理解什么线程，我么得先知道什么是进程。现代操作系统在运行一个程序时，会为其创建一个进程。例如启动eclipse.exe其实就是启动了win系统的一个进程。现代操作系统调度的最小单元就是线程，也叫轻量级进程，在一个进程里面包含多个线程，这些线程都有各自的计数器、堆栈等，并且能够共享内存变量。例如我们启动了一个eclipse进程，我们运行在其中的程序就可以理解为线程。
二、为什么要使用线程
（1）更多的处理器核心（可以运行更多的线程）。
（2）更快的响应时间（线程可以并行执行）。
（3）更好的编程模型。
三、线程的状态
Java线程在运行的生命周期中有6中不同的状态，在给定的一个时刻，线程只能处于其中一个状态。如下图所示。
创新互联公司的客户来自各行各业，为了共同目标，我们在工作上密切配合，从创业型小企业到企事业单位，感谢他们对我们的要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。专业领域包括成都网站设计、做网站、电商网站开发、微信营销、系统平台开发。
| 状态名称 | 说明 |
|---|---|
| NEW | 初始状态，线程被创建，但是还没有调用start方法。 |
| RUNNABLE | 运行状态，Java线程将操作系统中的就绪和运行两种状态统称地称作“运行中” |
| BLOCKED | 阻塞状态，表示线程阻塞于锁 |
| WAITING | 等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或中断） |
| TIME_WAITING | 超时状态，该状态不同于WAITING，它是可以在指定时间自行返回的 |
| TERMINATED | 停止状态，表示当前线程已经执行完毕 |
四、线程的调度（状态的变化）
我们先来看一张图：线程的调度对线程状态的影响
1）NEW(状态)线程创建未启动时的状态。如下代码示例：
Thread thread = new Thread(new ThreadTest());
System.out.println(thread.getState());输出结果：
NEW
Process finished with exit code 0
2）NEW-RUNNABLE线程调用start方法。如下代码示例：
Thread thread = new Thread(new ThreadTest());
thread.start();
System.out.println(thread.getState());输出结果：
RUNNABLE
线程调用yield（）方法，yield方法的作用就是让出CPU，当前线程从运行中变为可运行状态（READY），让和它同级或者更高级别的线程运行，但是不能保证运行的线程立马变成可运行状态（不确定的）。看如下代码示例：
代码设置了线程的优先级，但是测试了几次的测试结果都不相同。
**
* 测试yield方法
*/
public class ThreadYieldTest {
public static void main (String[] args) {
Thread threadone = new Thread(new ThreadTestOne(),"ThreadTestOne");
Thread threadtwo = new Thread(new ThreadTestTwo(),"ThreadTestTwo");
threadone.setPriority(Thread.MIN_PRIORITY);
threadtwo.setPriority(Thread.MAX_PRIORITY);
threadone.start();
threadtwo.start();
}
static class ThreadTestOne implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("ThreadTestOne----MIN_PRIORITY-----"+i);
Thread.yield();
}
}
}
static class ThreadTestTwo implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("ThreadTestTwo-----MAX_PRIORITY----"+i);
Thread.yield();
}
}
}
}
结果一：
ThreadTestOne----MIN_PRIORITY-----0
ThreadTestTwo-----MAX_PRIORITY----0
ThreadTestOne----MIN_PRIORITY-----1
ThreadTestTwo-----MAX_PRIORITY----1
结果二：
ThreadTestTwo-----MAX_PRIORITY----0
ThreadTestOne----MIN_PRIORITY-----0
ThreadTestTwo-----MAX_PRIORITY----1
ThreadTestOne----MIN_PRIORITY-----1
ThreadTestTwo-----MAX_PRIORITY----2
ThreadTestTwo-----MAX_PRIORITY----3
3）RUNNABLE-WAITING（调用wait、join等方法）
（1）、wait方法可以让一个线程的状态变为WAITING或者TIME_WAITING，wait方法的作用是让当前线程进入等待队列，让出CPU的执行权，线程的状态变化为等待状态，执行wait方法的前提就是获取到对象锁，因为执行线程需要知道进入谁的等待队列，之后才能被谁唤醒。看如下代码示例：（jps 看java的进程id,jstack 看java线程的信息）
static class Parent implements Runnable {
@Override
public void run() {
synchronized (lock){
System.out.println("执行lock.wait");
try {
lock.wait();
// 不会执行
System.out.println(Thread.currentThread().getName()+"----------"+Thread.currentThread().getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
通过命令看下线程信息如下图所示：可以看到Thread.State:WAITING
(2)、join方法也可以使线程以让一个线程的状态变为WAITING或者TIME_WAITING，join的方法的作用,字面意思加入、参加。我们可以这么理解join方法，一个线程加入一个正在运行的主线程中，并且使得正在运行的主线程等待加入的线程执行完毕才能继续执行。看如下代码示例：
1、我们在main方法启动两个线程，分别调用jion方法和不调用，看下执行结果一（不调用join方法）：
Parent-----------------
Child-----------
结果顺序不确定
Child-----------
Parent-----------------
public static void main (String[] args) {
Thread thread = new Thread(new Parent());
thread.setName("Parent");
Thread threadChild = new Thread(new Child());
threadChild.setName("Child");
thread.start();
threadChild.start();
}
/**
* 父线程
*/
static class Parent implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-----------------");
}
}
/**
* 子线程
*/
static class Child implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-----------");
}
}结果二（其中一个调用join方法）
(多次运行结果顺序不变)
Parent-----------------
Child-----------
public static void main (String[] args) {
Thread thread = new Thread(new Parent());
thread.setName("Parent");
Thread threadChild = new Thread(new Child());
threadChild.setName("Child");
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
threadChild.start();
}2、join方法源码
可以看出join方法是调用的wait方法，所以线程的状态会变成WAITING或者TIME_WAITING。
我们来分析下是哪个线程加入等待队列，可以看出join方法是个synchronized方法，也就是说锁对象就是调用者，然后拥有锁对象的线程调用wait方法进入等待队列。我们通过上面的main方法来分析到底是谁进入等待队列，主角有main线程、Parent线程、Child线程，我们在main线程里面new了Parent线程和Child线程，然后在Child线程启动前面调用了Parent线程的join方法，也就是说是Parent线程调用了join方法，所以锁对象就是Parent线程实例，我们再来分析是那个线程拥有这个锁对象，答案是main线程，所以main线程调用wait方法进入等待队列Parent线程执行完毕；join方法结束时会唤醒主线程。
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;
}
}
}4）RUNNABLE-TIME_WAITING（调用sleep、wait、join等方法）
sleep(long)方法就是让线程睡眠一定的时间在执行，不过这个是有时间限制的，到了时间就会又变成RUNNABLE状态。如下代码示例：
static class Parent implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println("-----------------------");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}结果
join(long)和wait(long)方法和WAITING状态的方式类似，只是加入时间后线程可以自动唤醒，自动从等待队列加入同步队列，获取到锁变成RUNNABLE状态。
sleep和wait的区别:
相同点：sleep和wait都可以使线程等待特定的时间；都可以使用interrupt()后调用阻塞方法中断线程；
不同点：sleep是Thread方法，wait是Object的方法；slepp到了时间自动唤醒，而wait没有规定时间时需要手动唤醒；在synchronized关键字修饰的方法或者块中，sleep不会释放锁，wait会释放锁。
4）TIME_WAITING or WAITING-RUNNABLE（调用notify()、notifyAll()，sleep时间到了)
sleep时间到了线程就会进入RUNNABLE状态（但是可能是RUNNING or READY状态）。
notify()是唤醒一个线程，进入同步队列，没有获取到锁就是BLOCKED状态，获取到锁就是RUNNABLE状态。
notifyAll()是唤醒等待队列的所有线程进入同步队列。
5）RUNNABLE-BLOCKED(线程获取锁失败，进入同步队列)
如下代码示例：
static class Parent implements Runnable {
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName()+"----------------------------------");
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 子线程
*/
static class Child implements Runnable {
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName()+"----------------------------------");
}
}
}结果
6）RUNNABLE-TERMINATED(线程执行完毕)
五、如何优雅终止线程（手动）
我们知道线程提供了interrupt()、stop()方法；中断线程的三种方式；
1）stop方法，停止一个线程，现在已经是一个过期方法（不推荐使用）。
代码示例：
public static void main (String[] args) throws InterruptedException {
Thread thread = new Thread(new Parent(),"Parent");
thread.start();
Thread.sleep(200);
thread.stop();
}
/**
* 父线程
*/
static class Parent implements Runnable {
@Override
public void run() {
while (true) {
System.out.println("-----------------------");
}
}
}2) 使用interrupt()方法，只是给线程设置了一个中断标记，并不会中断线程，配合阻塞方法才能实现线程的中断。
如下代码示例：
中断了
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.ge.thread.method.ThreadStopTest$Parent.run(ThreadStopTest.java:30)
at java.lang.Thread.run(Thread.java:745)
public static void main (String[] args) {
Thread thread = new Thread(new Parent(),"Parent");
thread.start();
thread.interrupt();
}
/**
* 父线程
*/
static class Parent implements Runnable {
@Override
public void run() {
try {
while (true) {
/*System.out.println("------------");
// 测试 isInterrupted方法
System.out.println("0isInterrupted------"+Thread.currentThread().isInterrupted());
// 测试interrupted方法
System.out.println("1interrupted------"+ Thread.interrupted());
System.out.println("2interrupted------"+ Thread.interrupted());*/
Thread.sleep(500);
}
}catch (InterruptedException e) {
e.printStackTrace();
System.out.println("中断了");
}
}
}interrupt、interrupted和isInterrupted方法的区别，大家可以运行上面注释代码看运行结果。
interrupt：给线程一个中断标记，配合阻塞方法中断线程，抛出InterruptedException异常，并清除标记。
interrupted：Thread的静态方法，返回线程的中断标记状态，并且清理，所以第一次返回true或者false，第二次一定是false。
isInterrupted：返回线程的中断标记状态。
3）给线程的执行设置一个标记，满足就执行，不满足就结束线程。
如下代码示例：
private static volatile boolean flag = true;
public static void main (String[] args) {
Thread thread = new Thread(new Parent());
thread.setName("Parent");
thread.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 中断线程标记
flag = false;
}
/**
* 父线程
*/
static class Parent implements Runnable {
@Override
public void run() {
while (flag && !Thread.currentThread().isInterrupted()) {
System.out.println("--------------");
}
}
}4）总结，stop方法就是强行结束线程，不推荐可能造成业务数据未知的错误，因为线程运行在那个过程时未知的；interrupt通过标记和阻塞方法一起中断线程，会抛出异常，但是要对异常做处理，例如处理线程为执行完成的任务或者回滚保证业务正确；推荐标记法，因为线程会走一个完整的过程，不会出现业务方面的未知错误，线程要么执行，要么不执行，不会执行一半就退出，所以就不会出现未知错误。
六、总结
本文针对线程的生命周期，线程的每个状态进行解释，以及线程执行过程的状态变化；线程调度对线程状态的影响，以及一些线程的基本方法；最后介绍了停止线程的三种方式；通过学习这些有助于我们理解线程的基础，为学习多线程打下基础，只有学习好了单线程，才能更好的学习多线程；希望与诸君共勉。
