test/jdk/java/util/concurrent/StructuredTaskScope/StructuredThreadDumpTest.java

*** 1,7 ***
  /*
!  * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ---
  /*
!  * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 29,10 ***
--- 29,11 ---
   * @library /test/lib
   * @run junit/othervm StructuredThreadDumpTest
   */
  
  import java.util.concurrent.StructuredTaskScope;
+ import java.util.concurrent.StructuredTaskScope.Joiner;
  import java.io.IOException;
  import java.lang.management.ManagementFactory;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.util.concurrent.ThreadFactory;

*** 51,12 ***
       * Test that a thread dump with a tree of task scopes contains a thread grouping for
       * each task scope.
       */
      @Test
      void testTree() throws Exception {
!         ThreadFactory factory = Thread.ofVirtual().factory();
-         try (var scope = new StructuredTaskScope<>("scope", factory)) {
              Thread thread1 = fork(scope, "child-scope-A");
              Thread thread2 = fork(scope, "child-scope-B");
              try {
                  ThreadDump threadDump = threadDump();
  
--- 52,11 ---
       * Test that a thread dump with a tree of task scopes contains a thread grouping for
       * each task scope.
       */
      @Test
      void testTree() throws Exception {
!         try (var scope = StructuredTaskScope.open(Joiner.awaitAll(), cf -> cf.withName("scope"))) {
              Thread thread1 = fork(scope, "child-scope-A");
              Thread thread2 = fork(scope, "child-scope-B");
              try {
                  ThreadDump threadDump = threadDump();
  

*** 81,11 ***
                  // thread1 and threads2 should be in threads array of "scope"
                  container1.findThread(thread1.threadId()).orElseThrow();
                  container1.findThread(thread2.threadId()).orElseThrow();
  
              } finally {
!                 scope.shutdown();
                  scope.join();
              }
          }
      }
  
--- 81,12 ---
                  // thread1 and threads2 should be in threads array of "scope"
                  container1.findThread(thread1.threadId()).orElseThrow();
                  container1.findThread(thread2.threadId()).orElseThrow();
  
              } finally {
!                 LockSupport.unpark(thread1);
+                 LockSupport.unpark(thread2);
                  scope.join();
              }
          }
      }
  

*** 93,15 ***
       * Test that a thread dump with nested tasks scopes contains a thread grouping for
       * each task scope.
       */
      @Test
      void testNested() throws Exception {
!         ThreadFactory factory = Thread.ofVirtual().factory();
-         try (var scope1 = new StructuredTaskScope<>("scope-A", factory)) {
              Thread thread1 = fork(scope1);
  
!             try (var scope2 = new StructuredTaskScope<>("scope-B", factory)) {
                  Thread thread2 = fork(scope2);
                  try {
                      ThreadDump threadDump = threadDump();
  
                      // thread dump should have a thread container for both scopes
--- 94,14 ---
       * Test that a thread dump with nested tasks scopes contains a thread grouping for
       * each task scope.
       */
      @Test
      void testNested() throws Exception {
!         try (var scope1 = StructuredTaskScope.open(Joiner.awaitAll(), cf -> cf.withName("scope-A"))) {
              Thread thread1 = fork(scope1);
  
!             try (var scope2 = StructuredTaskScope.open(Joiner.awaitAll(), cf -> cf.withName("scope-B"))) {
                  Thread thread2 = fork(scope2);
                  try {
                      ThreadDump threadDump = threadDump();
  
                      // thread dump should have a thread container for both scopes

*** 125,15 ***
  
                      // thread2 should be in threads array of "scope-B"
                      container2.findThread(thread2.threadId()).orElseThrow();
  
                  } finally {
!                     scope2.shutdown();
                      scope2.join();
                  }
              } finally {
!                 scope1.shutdown();
                  scope1.join();
              }
          }
      }
  
--- 125,15 ---
  
                      // thread2 should be in threads array of "scope-B"
                      container2.findThread(thread2.threadId()).orElseThrow();
  
                  } finally {
!                     LockSupport.unpark(thread2);
                      scope2.join();
                  }
              } finally {
!                 LockSupport.unpark(thread1);
                  scope1.join();
              }
          }
      }
  

*** 158,11 ***
  
      /**
       * Forks a subtask in the given scope that parks, returning the Thread that executes
       * the subtask.
       */
!     private static Thread fork(StructuredTaskScope<Object> scope) throws Exception {
          var ref = new AtomicReference<Thread>();
          scope.fork(() -> {
              ref.set(Thread.currentThread());
              LockSupport.park();
              return null;
--- 158,11 ---
  
      /**
       * Forks a subtask in the given scope that parks, returning the Thread that executes
       * the subtask.
       */
!     private static Thread fork(StructuredTaskScope<Object, Void> scope) throws Exception {
          var ref = new AtomicReference<Thread>();
          scope.fork(() -> {
              ref.set(Thread.currentThread());
              LockSupport.park();
              return null;

*** 176,20 ***
  
      /**
       * Forks a subtask in the given scope. The subtask creates a new child scope with
       * the given name, then parks. This method returns Thread that executes the subtask.
       */
!     private static Thread fork(StructuredTaskScope<Object> scope,
                                 String childScopeName) throws Exception {
          var ref = new AtomicReference<Thread>();
          scope.fork(() -> {
!             ThreadFactory factory = Thread.ofVirtual().factory();
!             try (var childScope = new StructuredTaskScope<Object>(childScopeName, factory)) {
                  ref.set(Thread.currentThread());
                  LockSupport.park();
              }
-             return null;
          });
          Thread thread;
          while ((thread = ref.get()) == null) {
              Thread.sleep(10);
          }
--- 176,19 ---
  
      /**
       * Forks a subtask in the given scope. The subtask creates a new child scope with
       * the given name, then parks. This method returns Thread that executes the subtask.
       */
!     private static Thread fork(StructuredTaskScope<Object, Void> scope,
                                 String childScopeName) throws Exception {
          var ref = new AtomicReference<Thread>();
          scope.fork(() -> {
!             try (var childScope = StructuredTaskScope.open(Joiner.awaitAll(),
!                     cf -> cf.withName(childScopeName))) {
                  ref.set(Thread.currentThread());
                  LockSupport.park();
              }
          });
          Thread thread;
          while ((thread = ref.get()) == null) {
              Thread.sleep(10);
          }