线程的状态
简单的来说，线程可以分为以下几种状态：
- 新建 （new）
- 就绪 （runnable）
- 运行中 （running）
- 阻塞 （blocking）
- 消亡 （dead）
Thread类主要方法
start() 启动线程
run() 一旦获取到cpu使用权，Thread会自动执行run方法
sleep() 线程等待时间（阻塞），此时该线程仍然占用cpu，注意sleep期间，线程是不会释放锁的
yield() 线程让出cpu使用权，重新进入就绪状态（也就是说，它并不会使当前线程进入阻塞状态），等待再次获取使用权，期间的间隔是不固定的，由系统分配。和sleep方法一样不会释放锁
join() 被join的线程进入等待状态（阻塞），等join()的线程执行完毕或者指定的时间以后，被join的线程才继续执行
jion()方法实际上最终调用了Object的wait()方法，让线程进入阻塞状态，释放锁，交出cpu使用权interrupt() 该方法使处于阻塞状态的线程抛出异常从而中断，可以用isInterrupted()和该方法来结束线程
总结一下：可以使线程进入阻塞状态的主要有两个：sleep()，join()，此时调用该线程的interrupt()方法就可以使当前线程抛出异常，我们可以在catch里进行释放操作（线程不会自己结束）
下面看一下代码：
static class A extends Thread{
@Override
public void run() {
for(int i = 0; i<1000; i ++){
System.out.print("Thread A ---> ");
System.out.println(i);
if( i == 100){
try {
b.join();
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}
}
}
static class B extends Thread{
@Override
public void run() {
for(int i = 0; i<100; i ++){
System.out.print("Thread B ---> ");
System.out.println(i);
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String...args){
a.start();
b.start();
System.out.println("A interrupt");
a.interrupt();
}
让A线程打印从1-1000，在打印到100的时候，把b线程join进来，同时在主线程调用a的interrupt()方法。执行结果如下：
A interrupt
Thread A ---> 0
Thread A ---> 1
.....
Thread A ---> 100
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Thread.join(Thread.java:1249)
at java.lang.Thread.join(Thread.java:1323)
at com.cris.app.threadTest$A.run(threadTest.java:41)
Thread B ---> 1
Thread B ---> 2
Thread B ---> 3
Thread B ---> 4
可以看到，主线程先执行了a.interrupt();，但是a线程并没有抛出异常，b线程也正常执行，直到 i=100的时候，由于b线程join进来，导致a线程阻塞，此时抛出了InterruptedException，而b线程一直正常执行到结束为止。
注意在catch里的break语句，线程是不会自己结束的，它只是抛出一个异常告诉我们，interrupt被置为了true，我们应该手动去处理它。
可以用interrupt()方法来结束线程，但是最好还是我们自己定义标志位来判断是否需要结束线程。
其他方法：
- getId()
- setName()
- getName()
- setPriority()
- getPriority()
- setDaemon() 设置线程是否成为守护线程和判断线程是否是守护线程
- isDaemon()
- currentThread() 静态方法，获取当前线程
守护线程：守护线程依赖于创建它的线程，而用户线程则不依赖，用户线程结束以后守护线程随之结束。比如jvm的垃圾收集器线程，jvm退出以后它自然也没有存在的必要了。
线程协作：wait，notify，notifyAll
这三个方法是Object类中的
- wait() 当前线程释放锁，进入等待状态
- notify() 通知其他任意一个等待状态的线程，使其结束等待状态
- notifyAll() 通知所有等待状态的线程结束等待状态
注意：notify() 和notifyAll只是通知线程结束等待状态，并不能保证哪个线程能获取到锁，如果当前线程没有获取到锁，那它将处于等待锁的状态。
static class ThreadA extends Thread{
@Override
public void run() {
synchronized (o){
try {
System.out.println(Thread.currentThread().getName() + " wait, release lock..");
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " stop wait, get lock");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " finished, release lock");
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
synchronized (o) {
System.out.println(Thread.currentThread().getName() + " Start sleep...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " stop sleep... notify, release lock..");
o.notifyAll();
}
}
}
static Object o = new Object();
public static void main(String...args){
for(int i=0; i<10; i++ ){
new ThreadA().start();
}
new ThreadB().start();
}
执行结果如下：
Thread-2 wait, release lock..
Thread-3 wait, release lock..
Thread-4 wait, release lock..
Thread-5 wait, release lock..
Thread-6 wait, release lock..
Thread-7 Start sleep...
Thread-7 stop sleep... notify, release lock..
Thread-6 stop wait, get lock
Thread-6 finished, release lock
Thread-5 stop wait, get lock
Thread-5 finished, release lock
Thread-4 stop wait, get lock
Thread-4 finished, release lock
Thread-3 stop wait, get lock
Thread-3 finished, release lock
Thread-2 stop wait, get lock
Thread-2 finished, release lock
首先开启了5个线程A（2-6），全部进入wait状态，但是并不持有锁，然后开启线程B(Thread-7),此时锁被该线程7获取并持有，调用notifyAll以后，所有的A线程被唤醒，但是锁只有一个，被线程6获取，在sleep过程中仍然持有锁，所以等待2秒之后线程6结束，释放锁，下一个线程才能获取到锁继续执行。
