Java 线程状态切换图 join，yield，sleep，wait

更多 Java 并发编程方面的文章，请参见文集《Java 并发编程》

---

Java 线程状态切换图

关于 Monitor

Monitor 是 Java 中用来实现线程间互斥与协作的主要手段，可以看成是对象或类的锁。
每个对象或类有且仅有一个 Monitor，在每个时刻，该 Monitor 只能被一个线程拥有，即 Active Thread。

Java 线程调度算法

Java 的线程调度是不分时的，采用抢占式调度模型：

• 优先让优先级高的线程占用 CPU
• 若优先级相同，则随机选择一个线程占用 CPU

如果明确希望一个线程给另一个线程运行的机会，可采用如下方式改变优先级：

• 当前运行状态的线程调用 Thread.yield()，进入 Ready 状态
• 当前运行状态的线程调用 Thread.sleep(1000)，进入 阻塞 Blocked 状态
• 当前运行状态的线程在，另一个线程调用 join()

线程的上下文 Context 切换

当线程被抢占时，发生上下文 Context 切换。
如果线程属于相同的进程，共享相同的地址空间，则上下文切换的多数信息对于线程不需要。

join() 方法

先看下面的代码：

public class Join_Test {
    public static void main(String[] args) throws Exception {
        MyThread t = new MyThread();
        t.start();

        System.out.println("Main Thread end");
    }
}

class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread start");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        System.out.println("MyThread end");
    }
}

上述的代码，在主线程中启动了子线程 t 后，主线程会继续执行，因此可能出现的输出如下：

MyThread start
Main Thread end
MyThread end

join() 方法用于控制不同线程间的执行顺序。使得当前线程阻塞，直至新加入的线程执行结束。
如果在 t.start(); 之后加上 t.join();，则主线程会等待子线程 t 执行结束才继续执行。输出如下：

MyThread start
MyThread end
Main Thread end

join() 方法也可以跟一个参数 public final synchronized void join(long millis)

Waits at most millis milliseconds for this thread to die. A timeout of 0 means to wait forever.

例如 t.join(100) 表示主线程最多阻塞 100 毫秒。在上面的例子中，线程 t 执行完需要 1000 毫秒，因此 t.join(100) 会导致主线程不会等到线程 t 执行完，就继续执行。

t.join(0) 等同于 t.join()

示例：如下的代码可以确保三个子线程按照 t1 t2 t3 的顺序依次执行：

public class Join_Test {
    public static void main(String[] args) throws Exception {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t1.join();

        t2.start();
        t2.join();

        t3.start();
        t3.join();
    }
}

class MyThread extends Thread {
    public void run() {
        System.out.println(Thread.currentThread().getName() + " start");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        System.out.println(Thread.currentThread().getName() + " end");
    }
}

输出如下：

Thread-0 start
Thread-0 end
Thread-1 start
Thread-1 end
Thread-2 start
Thread-2 end

Thread.yield() 方法 VS Thread.sleep() 方法

• 参数：
  • Thread.yield() 方法没有参数
  • Thread.sleep() 方法需要参数 毫秒，例如 1000，表示阻塞 1000 毫秒后进入 Ready 状态
• 线程状态的转变：
  • Thread.yield() 方法会导致当前线程从执行状态转变为 Ready 状态
  • Thread.sleep() 方法会导致当前线程从执行状态转变为 阻塞 Blocked 状态
• 是否会抛出异常：
  • Thread.yield() 方法不会抛出异常
  • Thread.sleep() 方法会抛出异常，因此需要 try - catch
• Thread.yield() 只会使得 相同或者更高优先级 的其他线程进入运行状态
• Thread.sleep() 方法不考虑优先级，任何的其他线程都可能会进入运行状态

Thread.sleep() 方法 VS obj.wait() 方法

• 参数：
  • Thread.sleep() 方法需要参数 毫秒，例如 1000，表示阻塞 1000 毫秒后进入 Ready 状态
  • obj.wait() 方法可以不带参数，也可以带参数
    • 带参数毫秒，例如 1000，表示 在 Waiting Pool 状态中等待 1000 毫秒后进入 Waiting for monitor entry 状态
    • 不带参数，表示 在 Waiting Pool 状态中永久等待，直至其他线程中调用 obj.notify() 或者 obj.notifyAll()，随后进入 Waiting for monitor entry 状态
• 所在类：
  • Thread.sleep() 方法在 Thread 类中，属于静态方法
  • obj.wait() 方法在 Object 类中，任何一个对象都可以调用 wait()
• 目的：
  • Thread.sleep() 方法用于线程控制自身流程
  • obj.wait() 方法用于线程间通信
• 线程状态的转变：
  • Thread.sleep() 方法会导致当前线程从执行状态转变为 阻塞 Blocked 状态
  • obj.wait() 方法会导致当前线程从执行状态转变为Waiting Pool 状态
• 锁：
  • Thread.sleep() 方法不会释放锁
  • obj.wait() 方法会释放锁