Java线程状态的一点笔记

初始->运行->终止，是一个正常执行的程序都会有状态，也是比较好理解的，从开始到销毁，例如执行下面的代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("hello world!!!");
    }
}

但是例外总是有的，这些例外都围绕着运行状态展开，让运行状态变得“不运行”。

让线程“不运行”的状态有三个，首先是阻塞，阻塞是因为对锁（synchronized锁）的竞争而出现的状态，例如下面的代码

public class Main {
    static int i = 0;
    public static synchronized void add() {
        i++;
    }
}

当有两个线程分别同时调用add()的时候，会因为锁，导致其中一个线程进入“阻塞”态，另外一个线程依然是“运行”态。

根据上面的图，我们还知道还有等待，也可以让线程“不执行”，那么这两者的区别是什么呢？

进入“阻塞”态是被动的，并不是由我们控制的，但是“等待”态是可以由我们进行控制的，然后还有对应的方法可以唤醒线程，使其从“等待”态变成“运行”态。

了解了这些区别后，“超时等待”态就很好理解了，给“等待”态设置一个时间，等待时间到了，就唤醒线程，使其从“等待”变成“运行”。

在聊到“等待”的时候，Java里面进入“等待”（包括“超时等待”）有两个方法，一个是wait()，一个是sleep()，两者也是有区别的。

第一个区别是wait()可以不设置超时时间，而sleep()必须设置超时时间，从功能上看，后者专门服务于“超时等待”。

第二个区别是wait()的使用是需要先获取到对象锁的，所以调用的时候会释放锁，而sleep()不需要，也不会释放锁。例如：

public class Main {
    Lock lock = new Lock();
    public static void add() {
        synchronized(lock) {
            lock.i++;
            lock.wait();
        }
    }

    public static class Lock {
        int i = 0;
    }
}

在上面的代码中，需要先获取lock的对象锁，然后才能使用wait()，使用wait()后，就会失去对象锁，lock对象就可以被别的线程调用。如果把lock.wait()替换成Thread.sleep()，就不会释放对象锁，别的线程想要调用lock对象就会被一直阻塞。

sleep()是“超时等待”，正常情况下，早晚都会让线程回到“运行”态，但是wait()需要怎么回到“运行”态呢？

在Object中，主要有下面几个与线程状态的方法，如下：

public class Object {
    public final void wait() throws InterruptedException {
        wait(0L);
    }
    public final native void wait(long timeoutMillis) throws InterruptedException;
    public final native void notify();
    public final native void notifyAll();
}

既然wait()是等待，那么notify()和notifyAll()自然就是唤醒啦，前者是唤醒一个线程，后者是唤醒所有，如果是唤醒所有，就会所有线程一起重新去竞争对象锁。