The attempt to transplant jtreg test GetStackTraceWhenRunnable.java from Loom has failed

[sunrise-cn]

GetStackTraceWhenRunnable.java移植失败情况说明

测试概要

移植任务介绍：
将loom的GetStackTraceWhenRunnable.java移植到TencentKonaFiber-8的相应位置下观察KonaFiber与Loom是否能产生一致行为，若不能则分析原因。

GetStackTraceWhenRunnable.java的测试目标：

确认当系统资只剩下一个platform thread时，且该platform thread已经被某一个virtual thread占用，其它处于runnable状态的virtual thread是否可以正常打印出调用栈信息。

测试代码分析

为方便叙述问题，相比原测试代码，我增加了thread1和thread2的名字：

• thread1.setName("virtual_thread1");
• thread2.setName("virtual_thread2");

/**
 * @test
 * @summary Test Thread::getStackTrace on a virtual thread that is runnable-unmounted
 * @run main/othervm -Djdk.virtualThreadScheduler.maxPoolSize=1 GetStackTraceWhenRunnable
 */

import java.io.IOException;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.Selector;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.LockSupport;

public class GetStackTraceWhenRunnable {

    public static void main(String[] args) throws Exception {
        try (Selector sel = Selector.open()) {

            // start thread1 and wait for it to park
            Thread thread1 = Thread.startVirtualThread(LockSupport::park);
            thread1.setName("virtual_thread1");  // 将thread1命名为"virtual_thread1"
            while (thread1.getState() != Thread.State.WAITING) {
                Thread.sleep(20);
            }

            // start thread2 to pin the carrier thread
            CountDownLatch latch = new CountDownLatch(1);
            Thread thread2 = Thread.startVirtualThread(() -> {
                latch.countDown();
                try {
                    sel.select();
                } catch (ClosedSelectorException e) {
                    // expected
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            });
            thread2.setName("virtual_thread2");  // 将thread2命名为"virtual_thread2"
            latch.await();   // wait for thread2 to run

            // unpark thread1 and check that it is "stuck" in the runnable state
            // (the carrier thread is pinned, no other virtual thread can run)
            LockSupport.unpark(thread1);
            for (int i = 0; i < 1; i++) {
                assertTrue(thread1.getState() == Thread.State.RUNNABLE);
                //Thread.sleep(100);
            }

            // print thread1's stack trace
            StackTraceElement[] stack = thread1.getStackTrace();
            assertTrue(stack.length > 0);
            for (StackTraceElement e : stack) {
                System.out.println(e);
            }
        }
    }

    static void assertTrue(boolean e) {
        if (!e) throw new RuntimeException();
    }
}

代码介绍：

• 环境准备：使用-Djdk.virtualThreadScheduler.maxPoolSize=1参数保证了ForkJoinPool里只有1个platform thread

• 测试代码任务：设定只有1个platform thread，通过一系列操做使得virtual thread1处于RUNNABLE状态，此时尝试它是否能够正常打印栈信息。

• 测试代码逐行分析：

  • 创建virtual_thread1：调用LockSupport#park()使其进入WAITING状态，这一步virtual_thread1从platform thread unmount下来。

  • 通过多路复用器selector，使virtual_thread2竞争上platform thread之后一直pin到该platform thread

  • 通过CoundDownLatch让main thread 等待，直到virtual_thread2占据到platform thread

  • main thread获得执行权后，继续向下执行。

  • 调用LockSupport#unpark()使virtual_thread1从WAITING转变为RUNNABLE状态。

    • 此时virtual_thread1一直尝试重新竞争上platform thread但始终竞争不上的状态。
    • 但此时virtual_thread1处于RUNNABLE状态。

  • 通过for循环连续判断5次virthread_thread1是否保持在RUNNABLE状态。

  • virtual_thread1调用getStackTrace()方法尝试获取栈信息。

    • 获取成功：打印栈信息
    • 获取失败：抛出RuntimeException

virtual_thread1和virtual_thread2的状态转换略图如所示：

其中虚拟线程的NEW,STARTED等状态暂忽略不表示。

从上图可，virtual_thread2的状态为RUNNING时，platform thread的状态确是RUNNABLE，这点从jstack打印的栈信息也可以看出来。这是因为执行sel.select()时实际上是不需要cpu资源的，所以这时platform thread的状态为RUNNABLE

"ForkJoinPool-1-worker-1" #22 daemon prio=5 os_prio=0 cpu=0.73ms elapsed=18.84s tid=0x00007fe8e8429430 nid=0x1d8e runnable [0x00007fe89ffa8000]
   java.lang.Thread.State: RUNNABLE     VirtualThread => name: virtual_thread2, state RUNNING  // ★★★
        at sun.nio.ch.EPollArrayWrapper.epollWait(Native Method)  
        at sun.nio.ch.EPollArrayWrapper.poll(EPollArrayWrapper.java:269)
        at sun.nio.ch.EPollSelectorImpl.doSelect(EPollSelectorImpl.java:93)
        at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86)
        - locked <0x00000007ad716bc8> (a sun.nio.ch.Util$3)
        - locked <0x00000007ad716330> (a java.util.Collections$UnmodifiableSet)
        - locked <0x00000007ad712d50> (a sun.nio.ch.EPollSelectorImpl)
        at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97)
        at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:101)
        at org.example.GetStackTraceWhenRunnable.lambda$main$0(GetStackTraceWhenRunnable.java:53)
        at org.example.GetStackTraceWhenRunnable$$Lambda$11/1450495309.run(Unknown Source)
        at java.lang.VirtualThread.lambda$new$0(VirtualThread.java:184)
        at java.lang.VirtualThread$$Lambda$8/1160460865.run(Unknown Source)
        at java.lang.Continuation.start(Continuation.java:111)

测试代码设计思路：

• 使用了NIO模型保证virtual_thread2一旦竞争上platform thread就不会再unmount下该线程。
• 使用LockSupport#park()和LockSupport#unpark()让virtual_thread1进入WAITING和RUNNABLE状态。
• 使用CountDownLatch让main thread等待virtual_thread2 mount上platform thread

virtual_thread1的状态转换过程图(详细)

VirtualThread的所有状态转换可在附录看到。

关于VirtualThread的getState()方法可在附录的virtualThread类的状态图部分中看到。

实际执行流程图

GetStackTraceWhenRunnable在KonaFiber和Loom里具体的调用过程可在详细调用流程图该链接中查看。

以下为缩略图展示：

执行测试

修改代码使得测试在KonaFiber中适配

根据GetStackTraceWhenRunnable.java在@test内的注释要求：

 * @test
 * @summary Test Thread::getStackTrace on a virtual thread that is runnable-unmounted
 * @requires vm.continuations
 * @run main/othervm -Djdk.virtualThreadScheduler.maxPoolSize=1 GetStackTraceWhenRunnable
 */

我做了如下配置

• 使用Tencent Kona v8.0.13-GA for Fiber作为Java SDK

• 在vm Options里设置-Djdk.defaultScheduler.parallelism=1。

  • 这是因为KonaFiber没有virtualThreadScheduler.maxPoolSize=1的相关配置，但是使用defaultScheduler.parallelism=1也可以起到限制线程数只有1个的作用

  该部分具体代码可在VirtualThread创建默认scheduler时看到

  loom

  // java.lang.VirtualThread#createDefaultScheduler
  private static ForkJoinPool createDefaultScheduler() {
      // ...
      PrivilegedAction<ForkJoinPool> pa = () -> {
              int parallelism, maxPoolSize, minRunnable;
              String parallelismValue = System.getProperty("jdk.virtualThreadScheduler.parallelism");
              String maxPoolSizeValue = System.getProperty("jdk.virtualThreadScheduler.maxPoolSize");  // ★★★在这里读取maxPoolSize属性★★★
              String minRunnableValue = System.getProperty("jdk.virtualThreadScheduler.minRunnable");
              if (parallelismValue != null) {
                  parallelism = Integer.parseInt(parallelismValue);
              } 
          // ...
          return new ForkJoinPool(parallelism, factory, handler, asyncMode,
                           0, maxPoolSize, minRunnable, pool -> true, 30, SECONDS);
          };
          return AccessController.doPrivileged(pa); 

  KonaFiber

  private static Executor createDefaultScheduler() {
  		// ...
          PrivilegedAction<Executor> pa = () -> {
              int parallelism;
              String propValue = System.getProperty("jdk.defaultScheduler.parallelism");  //★★★在这里读取parallelism属性★★★
              if (propValue != null) {
                  parallelism = Integer.parseInt(propValue);
              } 
              // ...
              return new ForkJoinPool(parallelism, factory, ueh, asyncMode);
          };
          return AccessController.doPrivileged(pa);
      }

  defaultScheduler.parallelism=1的解释

  简单来说，parallelism参数表明并行级别，ForkJoinPool根据该值来设定工作线程的数量。默认是cpu的核心数。这里手动设置成一，就相当于设置了只有一个线程。

  关于ForkJoinPool的一些个人想法和了解:

  无论是Loom还是KonaFiber都是用的ForkJoinPool作为线程池，我认为这样做是一种共赢的决策。

  • 首先解释ForkJoinPool
    • Fork/Join是一种支持分治任务模型的并行计算框架，它将任务分解成多个子任务(Fork)，最后再将各个子任务的结果进行合并(Join)。
    • ForkJoinPool是Fork/Join框架下的线程池类，它可以管理Fork/Join任务的线程。
  • 其次解释VirtualThread
    • VirtualThread封装了Continuation成为了一个协程，突破了线程数量受到现有内存大小的限制，甚至于可以创建数百万的协程。
  • 强强联手：1+ 1 > 2
    • ForkJoinPool可以将任务分治成多个子任务，达到可以并行计算一个大任务的作用
    • VirtualThread的数量非常多，可以同时执行这些子任务
    • 两者配合，可以充分利用到现在多核CPU的能力

  ForkJoinPool的一些知识：

  • 构造器的四个核心参数：
    • int parallelism：并行级别，ForkJoinPool根据该值来设定工作线程的数量。默认是cpu的核心数
    • ForkJoinWorkerThreadFactory factory：通过该factory来创建线程
    • UncaughtExceptionHandler handler：设定异常处理器，用来处理任务在运行中发生的错误
    • boolean asyncMode：设定队列的工作模式，asyncMode=true时：FIFO队列；asyncMode=false时：LIFO栈
  • 工作窃取算法：
    • 在普通线程池中是采用任务队列的方式来管理任务的，而工作窃取算法的核心思想就是：当一个线程完成自己的任务后，就可以从其它线程的队列中获取一个任务来执行，以此来提高线程的利用率。换句话说，就是允许空闲线程从繁忙线程的Deque中窃取工作任务。
    • 具体来说，ForkJoinPool在内部维护了多个任务队列，每当用户通过ForkJoinPool的invoke()/submit()提交任务后，ForkJoinPool都会根据一定的路由规则将其分配到一个任务队列中，如果任务在执行过程中fork出了子任务，就将子任务提交到该任务所在线程的任务队列中

预期行为(Loom的行为)

正常打印调用栈信息

java.base/jdk.internal.vm.Continuation.yield(Continuation.java:357)
java.base/java.lang.VirtualThread.yieldContinuation(VirtualThread.java:428)
java.base/java.lang.VirtualThread.park(VirtualThread.java:566)
java.base/java.lang.System$2.parkVirtualThread(System.java:2630)
java.base/jdk.internal.misc.VirtualThreads.park(VirtualThreads.java:54)
java.base/java.util.concurrent.locks.LockSupport.park(LockSupport.java:369)
java.base/java.lang.VirtualThread.run(VirtualThread.java:305)
java.base/java.lang.VirtualThread$VThreadContinuation.lambda$new$0(VirtualThread.java:177)
java.base/jdk.internal.vm.Continuation.enter0(Continuation.java:327)
java.base/jdk.internal.vm.Continuation.enter(Continuation.java:320)

实际行为

经修改适配KonaFiber代码后使用jtreg测试2分钟后报告超时。

result: Error. Program `/home/sunrise/work/java/konaJDK/TencentKona-8-Fiber-8.0.13-GA/build/linux-x86_64-normal-server-release/images/j2sdk-image/bin/java' timed out (timeout set to 120000ms, elapsed time including timeout handling was 120281ms).

test result: Error. Program `/home/sunrise/work/java/konaJDK/TencentKona-8-Fiber-8.0.13-GA/build/linux-x86_64-normal-server-release/images/j2sdk-image/bin/java' timed out (timeout set to 120000ms, elapsed time including timeout handling was 120281ms).

如果尝试直接执行该测试，则会发现该测试一直在执行，不会结束。

如何复现

• 若使用jtreg测试，修改@test里的参数为@run main/othervm -Djdk.defaultScheduler.parallelism=1 GetStackTraceWhenRunnable
• 若直接执行测试，在VM options里添加-Djdk.defaultScheduler.parallelism=1

问题分析

简要介绍

本次问题的最终原因定位在loom和konaFiber在java.lang.VirtualThread#tryGetStackTrace实现上的差异。

以下为逻辑分析，代码层面分析在后面会提及。

• 在loom中的实现

  Returns the stack trace for this virtual thread if it is unmounted. Returns null if the thread is in another state.

  当virtual thread的状态为unmounted时会返回一个stack trace，当virtual thread为runnable状态就属于这种情况，所以loom最终可以成功打印出信息。

• 在konaFiber的实现中

  Returns the stack trace for this virtual thread if it newly created, parked, or terminated. Returns null if the thread is in other states.

  当virtual thread的状态为newly created, parked, or terminated时才会返回stack tracke，virtual thread 为runnable状态就不属于这三种状态，因此会返回null。而在该方法的上层调用者java.lang.VirtualThread#getStackTrace中，当tryGetStackTrace()方法返回null时会陷入一个死循环中。

另外可以在附录中看到virtualThread类的状态图。

loom

像在详细调用流程图中所绘，最终会走到java.lang.VirtualThread#asyncGetStackTrace，调用java.lang.VirtualThread#tryGetStackTrace ，之后调用jdk.internal.vm.Continuation#getStackTrace 返回一个栈信息

// java.lang.VirtualThread#asyncGetStackTrace
StackTraceElement[] asyncGetStackTrace() {
        StackTraceElement[] stackTrace;
        do {
            stackTrace = (carrierThread != null)
                    ? super.asyncGetStackTrace()  // mounted
                    : tryGetStackTrace();         // unmounted  ★★★在这里调用tryGetStackTrace()方法★★★
            if (stackTrace == null) {
                Thread.yield();
            }
        } while (stackTrace == null);
        return stackTrace;
    }

因为virtual_thread2现在占据着platform thread，所以virtual_thread1的carrierThread一定为null，故最后会执行tryGetStackTrace();

---

// java.lang.VirtualThread#tryGetStackTrace 
private StackTraceElement[] tryGetStackTrace() {
        int initialState = state();
        return switch (initialState) {
            case RUNNABLE, PARKED -> {  //  这里是和KonaFiber产生差异的地方，当virtual_Thread1处于RUNNABLE时，会返回栈信息
                int suspendedState = initialState | SUSPENDED;
                if (compareAndSetState(initialState, suspendedState)) {
                    try {
                        yield cont.getStackTrace();  // ★★★在这里执行cont.getStackTrace()★★★
                    } finally {
                        assert state == suspendedState;
                        setState(initialState);

                        // re-submit if runnable
                        // re-submit if unparked while suspended
                        if (initialState == RUNNABLE
                            || (parkPermit && compareAndSetState(PARKED, RUNNABLE))) {
                            try {
                                submitRunContinuation();
                            } catch (RejectedExecutionException ignore) { }
                        }
                    }
                }
                yield null;
            }
            case NEW, STARTED, TERMINATED ->  new StackTraceElement[0];  // empty stack
            default -> null;
        };
    }

在第一处注释会判断virtual_Thread1是否处于RUNNABLE

• 此时是满足的，所以会将virtual_Thread1的状态加一个暂停标志，以防状态发生改变。
• 之后会执行try里的cont.getStackTrace()返回栈信息
• 并在执行完毕后，在finally里
  • 再次判断virtual_Thread1的状态在获取栈信息时是否发生改变，如果没有发生改变，将原状态恢复。
  • 如果virtual_Thread1是RUNNABLE或者可以恢复到RUNNABLE状态，则让contionuation继续执行任务

在这段代码里compareAndSetState(initialState, suspendedState)是一个CAS操作，一气呵成地尝试将virtual_thread1从initialState改为suspendedState。如果成功更改就返回true

---

// jdk.internal.vm.Continuation#getStackTrace   
public StackTraceElement[] getStackTrace() {
        return stackWalker(EnumSet.of(StackWalker.Option.SHOW_REFLECT_FRAMES))
            .walk(s -> s.map(StackWalker.StackFrame::toStackTraceElement)
            .toArray(StackTraceElement[]::new));
    }

在这里返回continuation的栈信息

KonaFiber

像在详细调用流程图中所绘，最终会走到java.lang.VirtualThread#getStackTrace方法中，然后在该方法中调用java.lang.VirtualThread#tryGetStackTrace()方法。

如以下所示：

//java.lang.VirtualThread#getStackTrace

    public StackTraceElement[] getStackTrace() {
        if (Thread.currentThread() == this) {
            return virtualThreadStackTrace((new Exception()).getStackTrace());
        } else {
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
                security.checkPermission(SecurityConstants.GET_STACK_TRACE_PERMISSION);
            }

            // target virtual thread may be mounted or unmounted
            StackTraceElement[] stackTrace;
            do {
                Thread carrier = carrierThread;
                if (carrier != null) {
                    // mounted
                    stackTrace = tryGetStackTrace(carrier);
                } else {
                    // not mounted
                    stackTrace = tryGetStackTrace();  //  ★★★最终会在这里调用tryGetStackTrace()方法。★★★
                }
                if (stackTrace == null) {
                    Thread.yield();
                }
            } while (stackTrace == null);
            return stackTrace;
        }
    }

这段代码里Thread.currentThread()是main thread，故会执行else语句，之后会在do -while循环里判断当前的virtual_thread1是否有carrierThread，如果没有就调用tryGetStackTrace()，尝试获取调用栈信息。之后tryGetStackTrace()会返回null。之后为了防止该循环一直在跑占据cpu资源，所以需要yield()一下，释放下cpu资源>

最终该方法会一直在执行do - while循环直到virtual_thread1 mount上一个platform thread或者在tryGetStackTrace()方法里获取到栈信息。

的状态变更为RUNNING(mount上platform thread)。

---

// java.lang.VirtualThread#tryGetStackTrace()
private StackTraceElement[] tryGetStackTrace() {
        if (compareAndSetState(PARKED, PARKED_SUSPENDED)) {
            try {
                return virtualThreadStackTrace(cont.getStackTrace());
            } finally {
                assert state == PARKED_SUSPENDED;
                setState(PARKED);

                // may have been unparked while suspended
                if (parkPermit == PARK_PERMIT_TRUE && compareAndSetState(PARKED, RUNNABLE)) {
                    try {
                        ScheduleContinuation();
                    } catch (RejectedExecutionException ignore) { }
                }
            }
        } else {
            int state = state();
            if (state == NEW || state == TERMINATED) {
                return EMPTY_STACK;
            } else {
                return null;  // ★★★ 在这里返回null ★★★
            }
        }
    }

compareAndSetState(PARKED, PARKED_SUSPENDED)是一个CAS操作，尝试将virtual_thread1的状态为PARKED时，将其设置为PARKED_SUSPENDED。

但此时virtual_thread1的状态为RUNNABLE，所以会返回false，从而执行到else语句里。之后最终会在注释处返回一个null，从而导致java.lang.VirtualThread#getStackTrace一直在做do - while循环

对CAS操作的解释：

• CAS操作包括三个运算符
  • 内存地址V
  • 期望值A
  • 新值B
• CAS的操作：会用A与V地址存放的值进行比较，如果相等(说明没有变化)就将V地址存放的值设为B。否则不做任何操作
• 由于cas操作不一定每次都会成功，所以就需要不断的重试，因此cas操作常写为循环CAS

这里的CAS操作，类似于加上一把锁，保证了在获取cont栈信息的时候，virtual_thread1的状态不会发生改变。

如何打破Do - While循环？

在java.lang.VirtualThread#getStackTrace中，会陷入死循环的原因是

1. virtual_thread1没有carrierthread，故只能执行

为什么会产生这种差异性？

这种差异性出现的原因可能是二者在java.lang.VirtualThread#tryGetStackTrace的实现不同，因为一个RUNNABLE的协程只要有空闲的platform就可以变为RUNNING，这样如果直接获取栈信息，就有可能拿到错误信息，所以需要对处于RUNNABLE状态的VirtualThread加以控制。

loom中是当VirtualThread处于RUNNABLE或者PARKED两种状态中，都进行这种加锁操作来获取栈信息。

同时这里会发现loom比KonaFiber还多了一个STARTED状态的判断，但是关于这个状态首先是二者一个是返回空栈信息，一个是返回null，在信息内容上基本区别不大，其次是处于该状态的VirtualThread本身就不会有调用栈信息。

//java.lang.VirtualThread#tryGetStackTrace
private StackTraceElement[] tryGetStackTrace() {
        int initialState = state();
        return switch (initialState) {
            case RUNNABLE, PARKED -> {  // 处于`RUNNABLE`或者`PARKED`两种状态就加锁
                int suspendedState = initialState | SUSPENDED;
                if (compareAndSetState(initialState, suspendedState)) {
                    try {
                        yield cont.getStackTrace();
                    } finally {
                        assert state == suspendedState;
                        setState(initialState);

                        // re-submit if runnable
                        // re-submit if unparked while suspended
                        if (initialState == RUNNABLE
                            || (parkPermit && compareAndSetState(PARKED, RUNNABLE))) {
                            try {
                                submitRunContinuation();
                            } catch (RejectedExecutionException ignore) { }
                        }
                    }
                }
                yield null;
            }
            case NEW, STARTED, TERMINATED ->  new StackTraceElement[0];  // empty stack
            default -> null;
        };
    }

而KonaFiber中是当VirtualThread处于PARKER状态中才进行加锁操作来获取栈信息。

//java.lang.VirtualThread#tryGetStackTrace
private StackTraceElement[] tryGetStackTrace() {
        if (compareAndSetState(PARKED, PARKED_SUSPENDED)) {  // 处于PARKER状态中才进行加锁
            try {
                return virtualThreadStackTrace(cont.getStackTrace());
            } finally {
                assert state == PARKED_SUSPENDED;
                setState(PARKED);

                // may have been unparked while suspended
                if (parkPermit == PARK_PERMIT_TRUE && compareAndSetState(PARKED, RUNNABLE)) {
                    try {
                        ScheduleContinuation();
                    } catch (RejectedExecutionException ignore) { }
                }
            }
        } else {
            int state = state();
            if (state == NEW || state == TERMINATED) {
                return EMPTY_STACK;
            } else {
                return null;
            }
        }
    }

---

RUNNING状态的virtualThread获取栈信息

这里也会有疑问，处于 RUNNING状态的virtualThread如何获取栈信息，这就要看tryGetStackTrace的调用者了

loom中的调用者是asyncGetStackTrace()，可以看到它会直接获取其carrierThread的栈信息

//java.lang.VirtualThread#asyncGetStackTrace
StackTraceElement[] asyncGetStackTrace() {
        StackTraceElement[] stackTrace;
        do {
            stackTrace = (carrierThread != null)
                    ? super.asyncGetStackTrace()  // mounted  // 调用Thread的asyncGetStackTrace()
                    : tryGetStackTrace();         // unmounted
            if (stackTrace == null) {
                Thread.yield();
            }
        } while (stackTrace == null);
        return stackTrace;
    }

再查看该方法，发现会直接尝试获取栈信息，若获取结果为null，就返回null；若获取空栈就返回空栈，否则就将结果返回。

    StackTraceElement[] asyncGetStackTrace() {
        Object stackTrace = getStackTrace0();
        if (stackTrace == null) {
            return null;
        }
        StackTraceElement[] stes = (StackTraceElement[]) stackTrace;
        if (stes.length == 0) {
            return null;
        } else {
            return StackTraceElement.of(stes);
        }
    }

KonaFiber的调用者是getStackTrace()，发现当VirtualThrea的状态为RUNNING时，其应该有carrierThread，故会调用tryGetStackTrace(carrier);来尝试获取栈信息。

// java.lang.VirtualThread#getStackTrace
public StackTraceElement[] getStackTrace() {
        if (Thread.currentThread() == this) {
            return virtualThreadStackTrace((new Exception()).getStackTrace());
        } else {
            SecurityManager security = System.getSecurityManager();
            if (security != null) {
                security.checkPermission(SecurityConstants.GET_STACK_TRACE_PERMISSION);
            }

            // target virtual thread may be mounted or unmounted
            StackTraceElement[] stackTrace;
            do {
                Thread carrier = carrierThread;
                if (carrier != null) {
                    // mounted
                    stackTrace = tryGetStackTrace(carrier);
                } else {
                    // not mounted
                    stackTrace = tryGetStackTrace();
                }
                if (stackTrace == null) {
                    Thread.yield();
                }
            } while (stackTrace == null);
            return stackTrace;
        }
    }

发现tryGetStackTrace()该方法会首先确认当前的carrierThread和形参carrier不是一个对象，这里有些不好理解，稍后会进一步讨论。

之后会将carrier的状态暂停

将判断当前VirtualThread对象的carrierThread就是形参carrier并且，当前virtualThread对象不处于PARKING状态，当这两个条件都满足后就获取栈信息。

• carrierThread == carrier：判断当前VirtualThread对象的carrierThread就是形参carrier，这一步确认传递过来的carrier线程就是自己的carrier线程，因为其他线程的会无法打印。
• state() != PARKING：判断当前VirtualThread对象的状态不是PARKING，因为PARKING状态是是一种中间变量，很快就会变化，如果park成功就会变为PARKED，如果park失败就会变为PINNED状态。

获取栈信息之后要将carrier的状态恢复。

// java.lang.VirtualThread#tryGetStackTrace(java.lang.Thread)
private StackTraceElement[] tryGetStackTrace (Thread carrier){
        assert carrier != Thread.currentCarrierThread();

        StackTraceElement[] stackTrace = null;
        carrier.suspend();
        try {
            if (carrierThread == carrier && state() != PARKING) {
                stackTrace = carrier.getStackTrace();
            }
        } finally {
            carrier.resume();
        }

        if (stackTrace != null) {
            return virtualThreadStackTrace(stackTrace);
        } else {
            return null;
        }
    }

可能的解决方案

因为该测试的情况属于极端情况，不是正常情况，因为正常情况下一个处于RUNNABLE状态的virtualThread肯定会很快获取到platform thread来执行任务。所以不进行改进可能也是可以的。

如果改进的话，也许可以考虑参考loom的实现，改为以下：

定义initialState状态标识当前virtualThread的状态，当状态为RUNNABLE,PARKED时加锁来获取栈信息，并在获取后解锁。

同时如果virtualThread的initialState是RUNNABLE，也要将其重新run()一下。

//java.lang.VirtualThread#tryGetStackTrace
private StackTraceElement[] tryGetStackTrace() {
    	int initialState = state();
    	if (initialState == RUNNABLE || initialState == PARKED) {
            int suspendedState = initialState | SUSPENDED;
            if (compareAndSetState(initialState, suspendedState)) {  // 处于PARKER状态中才进行加锁
            try {
                return virtualThreadStackTrace(cont.getStackTrace());
            } finally {
                assert state == suspendedState;
                setState(initialState);

                // may have been unparked while suspended
                // may have been runnable
                if (initialState == parkPermit RUNNABLE || (PARK_PERMIT_TRUE && compareAndSetState(PARKED, RUNNABLE))) {
                    try {
                        ScheduleContinuation();
                    } catch (RejectedExecutionException ignore) { }
                }
            }
        } 
        }
        else {
            int state = state();
            if (state == NEW || state == TERMINATED) {
                return EMPTY_STACK;
            } else {
                return null;
            }
        }
    }

附录

环境信息

使用jinfo -sysprops [pid]命令查看的java系统信息，以下只列出重要信息，完整信息在附件中查看。

java.runtime.name=OpenJDK Runtime Environment
sun.boot.library.path=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/amd64
java.vm.vendor=Tencent
jdk.defaultScheduler.parallelism=1
java.runtime.version=1.8.0_362_fiber-b2
os.name=Linux
os.version=5.15.90.1-microsoft-standard-WSL2
java.version=1.8.0_362_fiber

IDE：IntelliJ IDEA 2023.2 (Ultimate Edition)

virtualThread类的状态图示：

VirtualThread和Thread的状态对应关系

public Thread.State getState() {
        switch (state()) {
            case NEW:
                return Thread.State.NEW;
            case STARTED:
            case RUNNABLE:
                // runnable, not mounted
                return Thread.State.RUNNABLE;
            case RUNNING:
                // if mounted then return state of carrier thread
                synchronized (getBlockerLock()) {
                    Thread carrierThread = this.carrierThread;
                    if (carrierThread != null) {
                        return carrierThread.getState();
                    }
                }
                // runnable, mounted
                return Thread.State.RUNNABLE;
            case PARKING:
                // runnable, mounted, not yet waiting
                return Thread.State.RUNNABLE;
            case PARKED:
            case PARKED_SUSPENDED:
            case PINNED:
                return Thread.State.WAITING;
            case TERMINATED:
                return Thread.State.TERMINATED;
            default:
                throw new InternalError();
        }

完整jstack信息

Full thread dump OpenJDK 64-Bit Server VM (25.362-b2 mixed mode):

"Attach Listener" #24 daemon prio=9 os_prio=0 cpu=7.86ms elapsed=17.92s tid=0x00007fe870000e90 nid=0x1d9a waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: Attach Listener


"ForkJoinPool-1-worker-1" #22 daemon prio=5 os_prio=0 cpu=0.73ms elapsed=18.84s tid=0x00007fe8e8429430 nid=0x1d8e runnable [0x00007fe89ffa8000]
   java.lang.Thread.State: RUNNABLE     VirtualThread => name: virtual_thread2, state RUNNING
        at sun.nio.ch.EPollArrayWrapper.epollWait(Native Method)
        at sun.nio.ch.EPollArrayWrapper.poll(EPollArrayWrapper.java:269)
        at sun.nio.ch.EPollSelectorImpl.doSelect(EPollSelectorImpl.java:93)
        at sun.nio.ch.SelectorImpl.lockAndDoSelect(SelectorImpl.java:86)
        - locked <0x00000007ad716bc8> (a sun.nio.ch.Util$3)
        - locked <0x00000007ad716330> (a java.util.Collections$UnmodifiableSet)
        - locked <0x00000007ad712d50> (a sun.nio.ch.EPollSelectorImpl)
        at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:97)
        at sun.nio.ch.SelectorImpl.select(SelectorImpl.java:101)
        at org.example.GetStackTraceWhenRunnable.lambda$main$0(GetStackTraceWhenRunnable.java:53)
        at org.example.GetStackTraceWhenRunnable$$Lambda$11/1450495309.run(Unknown Source)
        at java.lang.VirtualThread.lambda$new$0(VirtualThread.java:184)
        at java.lang.VirtualThread$$Lambda$8/1160460865.run(Unknown Source)
        at java.lang.Continuation.start(Continuation.java:111)

"Write-Poller-0" #20 daemon prio=5 os_prio=0 cpu=0.23ms elapsed=18.85s tid=0x00007fe864085e20 nid=0x1d8d runnable [0x00007fe8bd0c5000]
   java.lang.Thread.State: RUNNABLEthread coroutine: Write-Poller-0

        at sun.nio.ch.EPoll.epollWait(Native Method)
        at sun.nio.ch.EPollPoller.poll(EPollPoller.java:74)
        at sun.nio.ch.Poller.poll(Poller.java:272)
        at sun.nio.ch.Poller.lambda$startPollerThread$0(Poller.java:125)
        at sun.nio.ch.Poller$$Lambda$2/1367388161.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:849)
        at sun.misc.InnocuousThread.run(InnocuousThread.java:112)

"Read-Poller-0" #19 daemon prio=5 os_prio=0 cpu=0.39ms elapsed=18.85s tid=0x00007fe8640834d0 nid=0x1d8c runnable [0x00007fe8bd1c6000]
   java.lang.Thread.State: RUNNABLEthread coroutine: Read-Poller-0

        at sun.nio.ch.EPoll.epollWait(Native Method)
        at sun.nio.ch.EPollPoller.poll(EPollPoller.java:74)
        at sun.nio.ch.Poller.poll(Poller.java:272)
        at sun.nio.ch.Poller.lambda$startPollerThread$0(Poller.java:125)
        at sun.nio.ch.Poller$$Lambda$2/1367388161.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:849)
        at sun.misc.InnocuousThread.run(InnocuousThread.java:112)

"Service Thread" #18 daemon prio=9 os_prio=0 cpu=0.11ms elapsed=18.90s tid=0x00007fe8e83bdb00 nid=0x1d88 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: Service Thread


"C1 CompilerThread11" #17 daemon prio=9 os_prio=0 cpu=17.77ms elapsed=18.90s tid=0x00007fe8e83bad90 nid=0x1d87 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C1 CompilerThread11


"C1 CompilerThread10" #16 daemon prio=9 os_prio=0 cpu=17.05ms elapsed=18.90s tid=0x00007fe8e83b9650 nid=0x1d86 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C1 CompilerThread10


"C1 CompilerThread9" #15 daemon prio=9 os_prio=0 cpu=16.80ms elapsed=18.90s tid=0x00007fe8e83b7b20 nid=0x1d85 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C1 CompilerThread9


"C1 CompilerThread8" #14 daemon prio=9 os_prio=0 cpu=16.86ms elapsed=18.90s tid=0x00007fe8e83b5ff0 nid=0x1d84 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C1 CompilerThread8


"C2 CompilerThread7" #13 daemon prio=9 os_prio=0 cpu=2.21ms elapsed=18.90s tid=0x00007fe8e83b44c0 nid=0x1d83 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread7


"C2 CompilerThread6" #12 daemon prio=9 os_prio=0 cpu=4.80ms elapsed=18.90s tid=0x00007fe8e83b2990 nid=0x1d82 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread6


"C2 CompilerThread5" #11 daemon prio=9 os_prio=0 cpu=4.94ms elapsed=18.90s tid=0x00007fe8e83b0e60 nid=0x1d81 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread5


"C2 CompilerThread4" #10 daemon prio=9 os_prio=0 cpu=3.13ms elapsed=18.90s tid=0x00007fe8e83af720 nid=0x1d80 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread4


"C2 CompilerThread3" #9 daemon prio=9 os_prio=0 cpu=2.21ms elapsed=18.90s tid=0x00007fe8e83a5c00 nid=0x1d7f waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread3


"C2 CompilerThread2" #8 daemon prio=9 os_prio=0 cpu=4.50ms elapsed=18.90s tid=0x00007fe8e83a40d0 nid=0x1d7e waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread2


"C2 CompilerThread1" #7 daemon prio=9 os_prio=0 cpu=5.02ms elapsed=18.90s tid=0x00007fe8e83a25a0 nid=0x1d7d waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread1


"C2 CompilerThread0" #6 daemon prio=9 os_prio=0 cpu=5.29ms elapsed=18.90s tid=0x00007fe8e803f930 nid=0x1d7b waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: C2 CompilerThread0


"Monitor Ctrl-Break" #5 daemon prio=5 os_prio=0 cpu=33.69ms elapsed=18.90s tid=0x00007fe8e83623e0 nid=0x1d7a waiting on condition [0x00007fe8be0d4000]
   java.lang.Thread.State: WAITING (parking)thread coroutine: Monitor Ctrl-Break

        at sun.misc.Unsafe.park(Native Method)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:328)
        at sun.nio.ch.VTSocketImpl.park(VTSocketImpl.java:109)
        at sun.nio.ch.VTSocketImpl.access$400(VTSocketImpl.java:40)
        at sun.nio.ch.VTSocketImpl$2$1.read0(VTSocketImpl.java:296)
        at sun.nio.ch.VTSocketImpl$2$1.read(VTSocketImpl.java:266)
        at sun.nio.ch.VTSocketImpl$2$1.read(VTSocketImpl.java:260)
        at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
        at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
        at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
        - locked <0x00000007adf258f8> (a java.io.InputStreamReader)
        at java.io.InputStreamReader.read(InputStreamReader.java:184)
        at java.io.BufferedReader.fill(BufferedReader.java:161)
        at java.io.BufferedReader.readLine(BufferedReader.java:324)
        - locked <0x00000007adf258f8> (a java.io.InputStreamReader)
        at java.io.BufferedReader.readLine(BufferedReader.java:389)
        at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:53)

"Signal Dispatcher" #4 daemon prio=9 os_prio=0 cpu=2.46ms elapsed=18.91s tid=0x00007fe8e8315720 nid=0x1d76 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLEthread coroutine: Signal Dispatcher


"Finalizer" #3 daemon prio=8 os_prio=0 cpu=0.18ms elapsed=18.93s tid=0x00007fe8e82e5b40 nid=0x1d70 in Object.wait() [0x00007fe8beceb000]
   java.lang.Thread.State: WAITING (on object monitor)thread coroutine: Finalizer

        at java.lang.Object.wait0(Native Method)
        - waiting on <0x00000007ad609430> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.Object.wait(Object.java:384)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
        - waiting to lock <0x00000007ad609430> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:188)

"Reference Handler" #2 daemon prio=10 os_prio=0 cpu=0.22ms elapsed=18.93s tid=0x00007fe8e82e1a60 nid=0x1d6f in Object.wait() [0x00007fe8bedec000]
   java.lang.Thread.State: WAITING (on object monitor)thread coroutine: Reference Handler

        at java.lang.Object.wait0(Native Method)
        - waiting on <0x00000007ad6070b8> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:384)
        at java.lang.Object.wait(Object.java:514)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - waiting to lock <0x00000007ad6070b8> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"main" #1 prio=5 os_prio=0 cpu=18890.73ms elapsed=18.94s tid=0x00007fe8e800aeb0 nid=0x1d59 runnable [0x00007fe8ecbdc000]
   java.lang.Thread.State: RUNNABLEthread coroutine: main

        at java.lang.Thread.yield0(Native Method)
        at java.lang.Thread.yield(Thread.java:305)
        at java.lang.VirtualThread.getStackTrace(VirtualThread.java:878)
        at org.example.GetStackTraceWhenRunnable.main(GetStackTraceWhenRunnable.java:72)

Print all Coroutines:

   Coroutine: 0x7fe824000b90  [thread coroutine]
        at java.lang.Continuation.run(Continuation.java:223)
        at java.lang.VirtualThread.runContinuation(VirtualThread.java:256)
        at java.lang.VirtualThread$$Lambda$9/603742814.run(Unknown Source)
        at java.util.concurrent.ForkJoinTask$RunnableExecuteAction.exec(ForkJoinTask.java:1402)
        at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
        at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1057)
        at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1694)
        at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:190)

   Coroutine: 0x7fe824000e90    VirtualThread => name: virtual_thread1, state RUNNABLE
        at java.lang.Continuation.yield0(Continuation.java:251)
        at java.lang.Continuation.yield(Continuation.java:298)
        at java.lang.VirtualThread.tryPark(VirtualThread.java:523)
        at java.lang.VirtualThread.park(VirtualThread.java:483)
        at java.lang.System$2.parkVirtualThread(System.java:1320)
        at sun.misc.VirtualThreads.park(VirtualThreads.java:55)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:326)
        at org.example.GetStackTraceWhenRunnable$$Lambda$1/2055281021.run(Unknown Source)
        at java.lang.VirtualThread.lambda$new$0(VirtualThread.java:184)
        at java.lang.VirtualThread$$Lambda$8/1160460865.run(Unknown Source)
        at java.lang.Continuation.start(Continuation.java:111)

"VM Thread" os_prio=0 cpu=1.05ms elapsed=18.93s tid=0x00007fe8e82da430 nid=0x1d6d runnable 

"GC task thread#0 (ParallelGC)" os_prio=0 cpu=0.07ms elapsed=18.94s tid=0x00007fe8e8042ad0 nid=0x1d5c runnable 

"GC task thread#1 (ParallelGC)" os_prio=0 cpu=0.08ms elapsed=18.94s tid=0x00007fe8e8043f50 nid=0x1d5d runnable 

"GC task thread#2 (ParallelGC)" os_prio=0 cpu=0.04ms elapsed=18.94s tid=0x00007fe8e80453d0 nid=0x1d5e runnable 

"GC task thread#3 (ParallelGC)" os_prio=0 cpu=0.06ms elapsed=18.94s tid=0x00007fe8e8046850 nid=0x1d5f runnable 

"GC task thread#4 (ParallelGC)" os_prio=0 cpu=0.05ms elapsed=18.94s tid=0x00007fe8e8047cd0 nid=0x1d60 runnable 

"GC task thread#5 (ParallelGC)" os_prio=0 cpu=0.07ms elapsed=18.94s tid=0x00007fe8e8049150 nid=0x1d61 runnable 

"GC task thread#6 (ParallelGC)" os_prio=0 cpu=0.14ms elapsed=18.94s tid=0x00007fe8e804a5d0 nid=0x1d62 runnable 

"GC task thread#7 (ParallelGC)" os_prio=0 cpu=0.16ms elapsed=18.94s tid=0x00007fe8e804ba50 nid=0x1d63 runnable 

"GC task thread#8 (ParallelGC)" os_prio=0 cpu=0.23ms elapsed=18.94s tid=0x00007fe8e804ced0 nid=0x1d64 runnable 

"GC task thread#9 (ParallelGC)" os_prio=0 cpu=0.20ms elapsed=18.94s tid=0x00007fe8e804e350 nid=0x1d65 runnable 

"GC task thread#10 (ParallelGC)" os_prio=0 cpu=0.16ms elapsed=18.94s tid=0x00007fe8e804f7d0 nid=0x1d66 runnable 

"GC task thread#11 (ParallelGC)" os_prio=0 cpu=0.16ms elapsed=18.94s tid=0x00007fe8e8050c50 nid=0x1d67 runnable 

"GC task thread#12 (ParallelGC)" os_prio=0 cpu=0.17ms elapsed=18.94s tid=0x00007fe8e80520d0 nid=0x1d68 runnable 

"GC task thread#13 (ParallelGC)" os_prio=0 cpu=0.16ms elapsed=18.94s tid=0x00007fe8e8053550 nid=0x1d69 runnable 

"GC task thread#14 (ParallelGC)" os_prio=0 cpu=0.11ms elapsed=18.94s tid=0x00007fe8e80549d0 nid=0x1d6a runnable 

"VM Periodic Task Thread" os_prio=0 cpu=5.76ms elapsed=18.90s tid=0x00007fe8e83bf960 nid=0x1d89 waiting on condition 

JNI global references: 347

完整jinfo sysprops信息

java.runtime.name=OpenJDK Runtime Environment
sun.boot.library.path=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/amd64
java.vm.version=25.362-b2
java.vm.vendor=Tencent
java.vendor.url=http\://jdk.oa.com/
path.separator=\:
java.vm.name=OpenJDK 64-Bit Server VM
file.encoding.pkg=sun.io
user.country=CN
sun.java.launcher=SUN_STANDARD
sun.os.patch.level=unknown
java.vm.specification.name=Java Virtual Machine Specification
user.dir=/home/sunrise/work/java/myJavaProject/testGetStackTraceWhenRunnable
jdk.defaultScheduler.parallelism=1
java.runtime.version=1.8.0_362_fiber-b2
java.awt.graphicsenv=sun.awt.X11GraphicsEnvironment
java.endorsed.dirs=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/endorsed
os.arch=amd64
java.io.tmpdir=/tmp
line.separator=\n
java.vm.specification.vendor=Oracle Corporation
os.name=Linux
sun.jnu.encoding=UTF-8
java.library.path=/usr/java/packages/lib/amd64\:/usr/lib64\:/lib64\:/lib\:/usr/lib
java.specification.name=Java Platform API Specification
java.class.version=52.0
sun.management.compiler=HotSpot 64-Bit Tiered Compilers
os.version=5.15.90.1-microsoft-standard-WSL2
user.home=/home/sunrise
user.timezone=Asia/Shanghai
java.awt.printerjob=sun.print.PSPrinterJob
file.encoding=UTF-8
java.specification.version=1.8
user.name=sunrise
java.class.path=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/charsets.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/cldrdata.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/dnsns.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/jaccess.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/localedata.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/nashorn.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/sunec.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/sunjce_provider.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/sunpkcs11.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext/zipfs.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jce.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jfr.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jsse.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/management-agent.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/resources.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/rt.jar\:/home/sunrise/work/java/myJavaProject/testGetStackTraceWhenRunnable/target/classes\:/home/sunrise/work/DevKits/idea-IU-232.8660.185/lib/idea_rt.jar
java.vm.specification.version=1.8
sun.java.command=org.example.GetStackTraceWhenRunnable
java.home=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre
sun.arch.data.model=64
user.language=zh
java.specification.vendor=Oracle Corporation
awt.toolkit=sun.awt.X11.XToolkit
java.vm.info=mixed mode
java.version=1.8.0_362_fiber
java.ext.dirs=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/ext\:/usr/java/packages/lib/ext
sun.boot.class.path=/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/resources.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/rt.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/sunrsasign.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jsse.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jce.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/charsets.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/lib/jfr.jar\:/usr/lib/jvm/TencentKona-8.0.13-362-fiber/jre/classes
java.vendor=Tencent
java.specification.maintenance.version=4
file.separator=/
java.vendor.url.bug=http\://ce.oa.com/bia
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.endian=little
sun.desktop=gnome
sun.cpu.isalist=

/