这是我参与11月更文挑战的第10天，活动详情查看：2021最后一次更文挑战

jvm线程

jvm实现线程需要考虑如何使用操作系统的线程。在jdk发行之初，采用的是用户线程，即多个jvm线程对应到一个操作系统线程，也称作绿色线程。但其存在的问题是，一些针对操作系统的线程监控工具并不适用，虽然jvm有自己的jstack工具，但无法对cpu占用进行查看，所以在后续版本中，jvm去掉了绿色线程，用户线程与操作系统的为1比1的关系。

其实我倒是感觉绿色线程有点协程的意思。

jvm线程状态

在jdk代码中，定义了线程的几种状态：

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         * new Thread()后，线程所处状态
         */
        NEW,

        /**
         * Thread state for a runnable thread.  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.
         * 当执行thrad.start()方法后，线程所处状态，有些博客也将该状态分为runnable(线程等待CPU资源)与running(线程获取到CPU执行权)状态
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         上面这段文字描述了几个让线程进入BLOCKED状态的场景
         1.线程在进入synchronized代码时争夺锁重量级锁失败导致线程挂起进入BLOCKED
         2.当线程从Object#wait()恢复后重新争抢重量级锁失败线程进入BLOCKED状态
         BLOCKED的定义为线程竞争锁失败
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         waiting状态用于表示线程等待另一个线程某个特定动作的执行
         上面说道三种情况进入WATING状态：
         1. Object#wait()
         2. Thread.join()
         3. LockSupport#park()
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         
         TIMED_WAITING表示线程等待其它线程的某个特定动作，但是只在限定时间等待
         以下方法使线程进入TIMED_WAITTING
         1. Thread.sleep()
         2. Object#wait(long)
         3. LockSupport#parkNanos(long)
         4. LockSupport#parkUntil(long)
         5. Thread.join(long)
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         
         TERMINATED用于表示一个线程已经执行完成
         */
        TERMINATED;
    }

需要注意的是BLOCKED状态，《并发编程的艺术》中没有提到Object#wait()后线程重新竞争重量级锁，也会进入BLOCKED状态，这也是容易忽视的一个点，从 BLOCKED状态表示线程竞争锁失败进入阻塞，会容易记住些。

感觉没啥可写了，下面说一下自己实际开发遇到的一个问题，使用线程异步执行时如何让traceId透传过下去。以下是我在项目中的使用方式:

public class TraceContext {
    public static ThreadLocal<String> traceContext = new ThreadLocal<>();
}

public class NewObjectTest {
    
    public static void main(String[] args) throws InterruptedException {
        // 设置当前线程的trace
        TraceContext.traceContext.set("main-traceId");
        Runnable r = () -> {
            // 设置子线程trace
            TraceContext.traceContext.set(TraceContext.traceContext.get());
            task();
        };
        Thread t = new Thread();
    }

    private static void task() {
        System.out.println(TraceContext.traceContext.get());
    }
}

好像阿里也有开源ThreadLocal透传的工具，大家用的什么方法呢，欢迎分享。