一、线程的状态
线程主要有四种状态，任何一个线程必然处于这四种状态其中的一种，具体的状态及转换流程如下：
1. New 初始化
在这个状态下，线程被初始化，但是尚未启动，所以也无法执行，这个状态处于我们new初始化了一个线程，但是并未调用起start()函数之前。
2. Runnable 可执行状态
在支持多线程的系统中会有一个排程器，主要是可以从线程池中选择一个线程，并且将其启动执行。
当线程处于可执行状态时，表示其可能处于线程池中等待排程器来启动执行，也有可能表示其正在执行。
所以在执行了线程的start()方法后，线程就变为可执行状态，但是此时并不是一定就在执行中。
3. Dead 死亡
当线程执行结束以后，就引入死亡状态。例如，线程类中的run()函数执行完毕以后，线程就进入到死亡状态。
4. Blocked 停滞，或者说锁定状态
当线程处于锁定状态时，系统排程器会将其忽略，不对其排程。线程自行等待所需资源被释放，或者重新被调用开始执行。
二、线程间的相互作用
多个线程之间需要进行一些协调通信，共同完成一件任务。通过查询Object的Api可以发现，Object直接提供三个操作线程的方法。之所以将线程通信的三个方法放在object类中，主要原因是在java中，每个对象都是可以有锁的，锁是针对于多线程的情况，那么就需要对象有操作线程释放或者获得锁的方法。
notify() 跳转查看API说明
唤醒一个监控当前对象的线程，也就是被当前对象锁住的线程。如果有多个线程在等待被唤醒，则随机选择一个唤醒。线程能够等待对象释放锁，是因为调用了对象的wait()方法中的一个。
被唤醒的线程也不能立即开始执行，需要等到当前线程释放对象的锁。被唤醒的线程同其他等待使用该对象的线程级别相同，在同下一个想要锁定该对象的线程没有什么竞争特权。
notify()方法应当是有拥有当前对象的锁的线程调用，一个线程想要拥有对象的锁有下面三种方式之一：
- 通过执行对象的synchronized同步代码块方法。
确保同一之间只能有一个线程执行此代码块，其他线程阻塞，知道当前代码块被执行完毕。 - 通过执行对象的synchronized同步代码块。
- 通过类对象，调用执行synchronized修饰的静态
static方法。
同一时间只能有一个对象获得对象的锁。在synchronized关键字的介绍中，我们也说过，如果一个线程调用了对象中的一个synchronized代码块或synchronized方法，则对象中的所有synchronized修饰的对象都被锁，或者说获得了对象的同步锁，其他线程想要调用该对象的同步代码块或同步方法，就必须要等到当前线程执行外代码块的内容，然后释放对象锁以后才可以。此处跳转查看synchronized关键字说明
notifyAll() 跳转查看API说明
notifyAll()方法同notify()方法基本相同，不同的是notifyAll()方法一次唤醒等待该对象锁的所有线程。
wait() 跳转查看API说明
调用wait()方法可以使得当前线程进入等待状态，直到被其他的线程对这个线程调用notify()方法或者notifyAll()方法，或者在指定的时间后运行。
调用此方法的当前线程必须要拥有当前对象的锁。
调用wait()方法后，当前线程(简称T)状态会设置为等待对象并且释放对象中所有的synchronized关键字修饰的方法或方法块。线程T进入阻塞状态，直到发生下面的四种情况：
- 其他线程调用了此对象的nodify()方法，线程T将在随机选择的情况下被唤醒
- 其他线程调用了对象的nodifyAll()方法，线程T被唤醒；
- 其他线程中断了线程T
- 指定了线程的实时运行时间，或多或少。如果超时时长为0，那么就不考虑线程在一直等待知道被唤醒。
为了确保调用wait()方法的时候，线程是持有对象锁的，因此必须将wait()方法放到同步代码块或同步代码中，如下代码：
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}
wait()方法和sleep()方法区别
线程调用wait()方法时，是直接释放对象锁的，当被重新唤醒后，是需要重新跟其他想要获得锁的线程一起重新竞争获得锁的。
线程调用sleep()方法时，需要指定休眠时长，线程会休眠指定时长，在休眠的过程中，线程不会释放对象锁，休眠时间结束后，线程继续执行。
实战代码演示
定义包含使用synchronized关键字修饰方法的对象
public class NumberHolder {
private int number;//声明计数变量
//定义增加同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
public synchronized void AddMethod() {
if (number != 0) {
try {
System.out.println("Add " + Thread.currentThread().getName() + " wait : " + number);
//持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number++;
System.out.println("Add " + Thread.currentThread().getName() + " : " + number);
//唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
notify();
}
//定义减数同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
public synchronized void MinMethod() {
if (0 == number) {
try {
System.out.println("Min " + Thread.currentThread().getName() + " wait : " + number);
//持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number--;
System.out.println("Min " + Thread.currentThread().getName() + " : " + number);
//唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
notify();
}
}
定义线程对象
public class AddThread extends Thread {
private NumberHolder numberHolder;
public AddThread(NumberHolder numberHolder, String strThreadName) {
this.numberHolder = numberHolder;
this.setName(strThreadName);
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
numberHolder.AddMethod();
}
}
}
public class MinThread extends Thread {
private NumberHolder numberHolder;
public MinThread (NumberHolder numberHolder, String strThreadName) {
this.numberHolder = numberHolder;
this.setName(strThreadName);
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
try {
Thread.sleep((long)(Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
numberHolder.MinMethod();
}
}
}
新起两个线程同时调用对象，实现线程调用对象的锁的实现和wait()方法和notify()方法的使用。
public static void main(String[] args) {
NumberHolder numberHolder = new NumberHolder();
AddThread addThread1 = new AddThread(numberHolder, "addThread1");
MinThread minThread2 = new MinThread(numberHolder, "minThread2");
addThread1.start();
minThread2.start();
}
执行结果为 多次执行结果不同
Add addThread1 : 1
Min minThread2 : 0
Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0
Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0
从上述结果中，可以看出两个线程依次执行增加和减少方法，结果正确，但是如果我们将线程数量增加到四个，情况会是如何？请看代码
public static void main(String[] args) {
NumberHolder numberHolder = new NumberHolder();
AddThread addThread1 = new AddThread(numberHolder, "addThread1");
MinThread minThread2 = new MinThread(numberHolder, "minThread2");
AddThread addThread3 = new AddThread(numberHolder, "addThread3");
MinThread minThread4 = new MinThread(numberHolder, "minThread4");
addThread1.start();
minThread2.start();
addThread3.start();
minThread4.start();
}
执行结果，多次执行结果不同
Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0
Min minThread4 wait : 0
Add addThread3 : 1
Min minThread4 : 0
Min minThread2 wait : 0
Min minThread4 wait : 0
Add addThread3 : 1
Min minThread2 : 0
Min minThread4 : -1
Min minThread4 : -2
Add addThread1 wait : -2
Min minThread2 : -3
Add addThread1 : -2
Add addThread1 wait : -2
Add addThread3 wait : -2
当两个线程的时候，线程顺序切换，数据正常，但是当线程数量增加到四个的时候，执行结果就发生了错误。
判断错误的原因可能是由于在两个线程时，一个执行，一个在wait，因此当增加的线程运行时，减少的线程在等待，当增加的线程调用modify后，唤醒的就是减少的线程，因此数据正确。
而在四个线程的时候，当前线程在运行时，调用nodify唤醒的可能是如下情况的三种进程
- 从未开始执行的线程，因为没有获得对象锁，而直接进入等待状态的；
- 获得过对象锁，且执行结束，释放锁之后进入等待状态的；
- 获得过对象锁，执行时条件不满足，调用了wait方法进入等待状态的；
这三种情况下的进程都有可能是增加或者减少，如果连续两次唤醒的都是减少的存储过程，且可能有减少的存储过程是调用了wait方法进入等待状态的，在num已经等于0，或者小于0的情况下，继续执行方法，对number值进行减少，导致出现-1甚至是-2的情况。
解决这种问题的方法很简单，就是避免某个线程是执行到wait方法时进入等待状态的，重新唤醒时没有进行number值的判断，就直接执行number值操作的情况。可以将if直接修改为while即可，代码如下：
public class NumberHolder {
private int number;//声明计数变量
//定义增加同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
public synchronized void AddMethod() {
while (number != 0) {
try {
System.out.println("Add " + Thread.currentThread().getName() + " wait : " + number);
//持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number++;
System.out.println("Add " + Thread.currentThread().getName() + " : " + number);
//唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
notify();
}
//定义减数同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
public synchronized void MinMethod() {
while (0 == number) {
try {
System.out.println("Min " + Thread.currentThread().getName() + " wait : " + number);
//持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number--;
System.out.println("Min " + Thread.currentThread().getName() + " : " + number);
//唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
notify();
}
}
while方法体，在条件不满足的时候，会循环执行，直至满足条件才会结束循环
