Java 线程理解

Java定义的线程状态

1. NEW
   还没有启动的线程，即new Thread(),之后没有调用start的线程
2. RUNNABLE
   可运行线程的线程状态。一个处于可运行状态的线程表示正在java 虚拟机中执行的线程，但是，它可能正在等待操作系统的一些资源，比如处理器
3. BLOCKED
   为了获取锁（Monitor lock）而阻塞线程的 线程状态。一个处于BLOCK状态的线程是为了获取一个锁（a monitor lock）去进入一个synchronized代码块/方法，或者在调用Object.wait之后，重新进入一个synchronized代码块或方法。
4. WATTING
   正在等待的 线程状态。以下几种方法会让一个线程处于waiting状态：
   ① Object.wait 没有超时时间（with no timeout）
   ② Thread.join 没有超时时间
   ③ LockSupport.park
   一个处于waiting状态的线程，是为了等待另一个线程去执行一个特殊的行为。
   举个例子： 在一个对对象上已经调用Object.wait的线程是为了等待另外一个线程在那个对象上，去调用Object.notify()或Object.notifyAll()。一个调用了Thread.join()的线程，是为了等待一个特殊的线程终止。
5. TIMED_WAITING
   具有指定等待时间的线程等待状态。
   线程因为调用了以下方法之一，并指定了一个正的等待时间，才进入了TIMED_WAITING：
   ① Thread.sleep（）
   ② Object.wait 有超时时间
   ③ Thread.join 有超时时间
   ④ LockSupport.parkNanos
   ⑤ LockSupport.parkUntil
6. TERMINATED
   线程终止状态。该线程已经执行完了。

java线程的部分方法

1. Thread.join()
   等待线程死亡。即等待线程执行完毕。
   在父线程中，调用子线程的join，则父线程需要等待子线程结束才能继续运行。

public class JoinTest {

    public static void main(String[] args) {
        Parent parent = new Parent();
        parent.start();
    }

}


// 父线程
class Parent extends Thread {
    public void run() {
        Thread child = new Thread(new Child("子线程"));
        System.out.println("子线程之前-----------------");
        child.start();
        try {
            child.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程之后-----------------");

    }
}

class Child implements Runnable{

    private String name;

    public Child(String name){
        this.name = name;
    }


    @Override
    public void run() {
        for (int i = 0; i < 100; i++){
            System.out.println("线程" + name + "===============================>" + i);
        }
    }
}

3. Thread.Interrupt
   interrupt 只能改变线程的中断状态，不能中断正在运行的线程。

4. Object.wait
   指定对象上，需要先获取一个锁（synchronized），然后，调用该对象的wait方法，则此线程会进入等待状态，并释放，获取的锁，直到其它线程，调用notify（唤醒该对象上的一个线程）notifyAll（唤醒该对象上的所有线程）， 而sleep也是进入等待状态，区别就是，sleep不是必须先获取一个锁， 如果获取了，调用sleep之后，也不会释放获取的锁。