Thread

通用线程状态

线程是操作系统的概念,不同的开发语言都对齐进行了封装,Java 语言里的线程本质上就是操作系统的线程,它们是一一对应的。

通用的线程生命周期有五种状态:初始状态、可运行状态、运行状态、休眠状态终止状态

  • 初始状态:指的是线程已经被创建,但是还不允许分配 CPU 执行。这个状态属于编程语言特有的,这里的创建仅仅在编程语言中创建,但是没有在操作系统层面创建。

  • 可运行状态:线程可以分配 CPU 执行,真正的操作系统线程已经被创建了。

  • 运行状态:被分配到 CPU 的线程的状态。

  • 休眠状态:运行状态的线程如果调用一个阻塞的 API(例如以阻塞方式读文件)或者等待某个事件(例如条件变量),那么线程的状态就会转换到此状态,同时释放 CPU 使用权,休眠状态的线程永远没有机会获得 CPU 使用权。

  • 终止状态:线程执行完或者出现异常。

这五种状态在不同的编程语言里面会有简化,如C 语言的 POSIX Threads 规范,就把初始状态和可运行状态合并了;Java 语言里则把可运行状态和运行状态合并了。

除了合并,也会有细化,Java 语言里就细化了休眠状态。

Java 线程状态

java.lang.Thread.State 定义了 Java 线程的6种状态。

public class Thread implements Runnable {
     /**
     * These states are virtual machine states which do not reflect
     * any operating system thread states.
     */
    public enum State {
        NEW,
        /**
         * A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }
}
  • NEW:new 了一个 Thread 对象,但未调用 start()方法。

  • RUNNABLE:调用了 Thread 的 start()方法后进入的状态,可以被 CPU 调度。

  • BLOCKED:线程阻塞在进入synchronized关键字修饰的方法或代码块时的状态。

  • WAITING:不会被分配 CPU 执行时间,它们要等待被显式地唤醒,否则会处于无限期等待的状态。

  • TIMED_WAITING:不会被分配 CPU 执行时间,需要被显示地唤醒,或达到一定时间后自动唤醒。

  • TERMINATED:线程已经执行完毕,不可逆转。若再调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

  1. 有人觉得 Java 线程状态中还少了个 running 状态,但这其实是把两个不同层面的状态混淆了。

  2. Java 线程没有 running 的概念,它的 RUNNABLE 包含了 操作系统的 ready 和 running 两种状态。

  3. 注意看 State 的注释,Java 线程状态是虚拟机层面的,不会反映操作系统的线程状态。

  4. Java 不需要 running 状态是因为没有必要去区分,操作系统的 CPU 时间片段一般很小,10-20ms 左右,Java 去区分是没有意义的。

BLOCKED、WAITING、TIMED_WAITING 可以理解为线程导致休眠状态的三种原因。

Java 线程状态转换

线程调用阻塞式 API 时,不会进入 BLOCKED 状态,在操作系统层面是休眠状态,但是在 JVM 层面还是 RUNNABLE 状态。因为在 JVM 看来,等待 CPU 使用权(操作系统层面此时处于可执行状态)与等待 I/O(操作系统层面此时处于休眠状态)没有区别,都是在等待某个资源,所以都归入了 RUNNABLE 状态。

每个对象锁都对应一个等待队列和一个同步队列,详情见下一节。下图是一个线程状态转换的例子。

线程状态转换相关方法

  1. Thread.sleep(long millis):一定是当前线程调用此方法,当前线程进入 TIMED_WAITING 状态,但不释放对象锁,millis 后线程自动苏醒进入就绪状态。是给其它线程执行机会的最佳方式。

  2. Thread.yield():一定是当前线程调用此方法,当前线程放弃获取的 CPU 时间片,但不释放锁资源,由运行状态变为就绪状态,让 OS 再次选择线程。作用:让相同优先级的线程轮流执行,但并不保证一定会轮流执行。实际中无法保证 yield() 达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与 sleep()类似,只是不能由用户指定暂停多长时间。

  3. thread.join():当前线程里调用其它线程 t 的join()方法,当前线程进入 WAITING/TIMED_WAITING 状态,当前线程不释放已经持有的对象锁。线程 t 执行完毕或者 millis 时间到,当前线程一般情况下进入 RUNNABLE 状态,也有可能进入 BLOCKED 状态(因为join()是基于wait()实现的)。

  4. thread.interrupt()

    • 若线程 A 处于 WAITING 或 TIMED_WAITING 状态时,线程 B 调用线程 A 的 interrupt 方法,则会使线程 A 进入 RUNNABLE 状态,触发 InterruptedException;

    • 若线程 A 处于 RUNNABLE 状态,并阻塞在java.nio.channels.InterruptibleChannel上时,调用线程 A 的 interrupt 方法,会触发java.nio.channels.ClosedByInterruptException

    • 若线程 A 处于 RUNNABLE 状态,阻塞在java.nio.channels.Selector上时,调用线程 A 的 interrupt 方法,线程 A 会立即返回;

    • 若线程 A 处于 RUNNABLE 状态,并没有阻塞在任何 I/O 操作上,调用线程 A 的 interrupt 方法,线程 A 可以通过主动监测的方式(isInterrupted)判断自己是否已经被中断;也可忽略中断。

  5. obj.wait():当前线程调用对象的wait()方法,当前线程释放对象锁,进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout 时间到自动唤醒。

  6. obj.notify():唤醒在此对象监视器上等待的单个线程,选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

  7. LockSupport.park(), LockSupport.parkUntil(long deadlines):当前线程进入 WAITING/TIMED_WAITING 状态。对比wait()方法,不需要获得锁就可以让线程进入 WAITING/TIMED_WAITING状态,需要通过LockSupport.unpark(Thread thread)唤醒。

join()的本质

join()的本质是先调用synchronized方法获取线程的锁,然后调用wait()方法,当线程 terminate 的时候,会调用notifyAll()方法。

public class Thread implements Runnable {
    /**
     * As a thread terminates the {@code this.notifyAll} method is invoked. 
     * It is recommended that applications 
     * not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     */
    public final synchronized void join(long millis) throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
}

Reference

线程的个数

CPU 密集型

对于 CPU 密集型的计算场景,理论上“线程的数量 =CPU 核数”就是最合适的。不过在工程上,线程的数量一般会设置为“CPU 核数 +1”,这样的话,当线程因为偶尔的内存页失效或其他原因导致阻塞时,这个额外的线程可以顶上,从而保证 CPU 的利用率。

IO 密集型

线程数量=CPU核数(1+I/O耗时÷CPU耗时)线程数量 = CPU 核数 * (1 + I/O 耗时 ÷ CPU 耗时)

终止线程

Interrupt

线程执行完 run() 方法后,会自动转换到 TERMINATED 状态,当然如果执行 run() 方法的时候异常抛出,也会导致线程终止。

有时候我们需要强制终止线程,Thread.stop() 可以做到,不过已经标记为 @Deprecated,所以不建议使用了。应该调用 interrupt() 方法。

stop() 会真的杀死线程,不给线程喘息的机会,如果线程持有 synchronized 隐式锁,也不会释放,很危险。类似的方法还有 suspend()resume() 方法,这两个方法同样也都不建议使用了。

interrupt() 就好多了,仅仅是通知线程。

  • interrupt():给线程发一个中断信号。

  • isInterrupted():判断线程是否中断,不会清除中断状态。

  • interrupted():判断线程是否中断,会清除中断状态。

  • 抛出中断异常:会清除中断状态,表示可以接受下一个中断信号了。

public class Thread implements Runnable {
    public static boolean interrupted() {
        return currentThread().isInterrupted(true);
    }
    
    public boolean isInterrupted() {
        return isInterrupted(false);
    }
    
    /**
     * Tests if some Thread has been interrupted.  The interrupted state
     * is reset or not based on the value of ClearInterrupted that is
     * passed.
     */
    private native boolean isInterrupted(boolean ClearInterrupted);
    
    /**
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public static native void sleep(long millis) throws InterruptedException;
}

两阶段终止模式

前辈总结出一套成熟的终止线程的方案,归纳出一种设计模式:两阶段终止模式。简单来说,分为两个步骤:

  1. T1 向 T2 发送终止指令;

  2. T2 响应终止指令。

如下是一个两阶段终止的例子:

public final class Example1 {

    private Thread t = null;
    private boolean started = false;

    public synchronized void start() {
        if (started) return;

        started = true;
        t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                report();
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            started = false;
        });
        t.start();
    }

    public synchronized void stop() {
        if (t != null) {
            t.interrupt();
        }
    }

    private void report() { }
}

但是上述方式有点问题,如果 report 中使用了第三方类库,我们没法保证第三方类库正确处理了线程中断异常,所以应该使用自己的线程中断标志位

public final class Example2 {

    private volatile boolean terminated = false;
    private Thread t = null;
    private boolean started = false;

    public synchronized void start() {
        if (started) return;

        started = true;
        terminated = false;
        t = new Thread(() -> {
            while (!terminated) {
                report();
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            started = false;
        });
        t.start();
    }

    public synchronized void stop() {
        terminated = true;
        if (t != null) {
            t.interrupt();
        }
    }

    private void report() { }
}

终止线程池

  • shutdown()

    • 拒绝接受新任务;

    • 等待正在执行的任务完成;

    • 等待已经进入阻塞队列的任务完成;

  • shutdownNow()

    • 拒绝接受新任务;

    • 中断正在执行的任务;

    • 已经进入阻塞队列的任务也不会再执行,但是会作为方法的返回值,可以让用户对这些任务再次处理;

    • 所以使用 shutdownNow 方法终止线程池,要求任务能够正确处理线程中断。

Last updated