* <p>
 * <strong>Thread-Safety:</strong> This class is <strong>NOT thread-safe</strong>.
 * It extends {@link LinkedHashMap} without synchronization. If multiple threads access
 * an instance concurrently, and at least one thread modifies the map structurally,
 * it must be synchronized externally.
 * </p>
 * <p>
 * For thread-safe usage, wrap with {@link java.util.Collections#synchronizedMap(Map)}:

            });
    assertFalse(task.isDone());
    Thread thread =
        new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  task.run();
                } finally {
                  exitLatch.countDown();
                }
              }
            });
    thread.start();
    enterLatch.await();

                }
            }).start();
        }

        // Signal all threads to start at once
        startLatch.countDown();

        // Wait for all threads to complete
        assertTrue("Threads did not complete in time", doneLatch.await(5, TimeUnit.SECONDS));

        // All threads should fail with the same IOException (endpoint is blank)

              @Override
              public Integer call() {
                return Thread.currentThread().getStackTrace().length;
              }
            },
            directExecutor());
    settableFuture.set(null);
    assertThat(getDone(stackDepthCheck))
        .isLessThan(Thread.currentThread().getStackTrace().length + 100);
  }

  /**
   * Returns an exception handler that exits the system. This is particularly useful for the main
   * thread, which may start up other, non-daemon threads, but fail to fully initialize the
   * application successfully.
   *
   * <p>Example usage:
   *
   * <pre>
   * public static void main(String[] args) {
   *   Thread.currentThread().setUncaughtExceptionHandler(UncaughtExceptionHandlers.systemExit());
   *   ...
   * </pre>
   *

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    CountDownLatch successLatch = new CountDownLatch(1);

    // Run cancellation in a separate thread as an extra thread-safety test.
    new Thread(
            () -> {
              assertThrows(CancellationException.class, future::get);
              successLatch.countDown();
            })
        .start();

        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {
      thread = new Thread((ThreadGroup) null, finalizer, threadName);
    }
    thread.setDaemon(true);

    try {
      if (inheritableThreadLocals != null) {
        inheritableThreadLocals.set(thread, null);
      }
    } catch (Throwable t) {
      logger.log(

            return jvmGcObj;
        }).toArray(n -> new JvmGcObj[n]);
        final Threads threads = jvmStats.getThreads();
        final JvmThreadsObj jvmThreadsObj = new JvmThreadsObj();
        jvmObj.threads = jvmThreadsObj;
        jvmThreadsObj.count = threads.getCount();
        jvmThreadsObj.peak = threads.getPeakCount();
        final Classes classes = jvmStats.getClasses();

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    CountDownLatch successLatch = new CountDownLatch(1);

    // Run cancellation in a separate thread as an extra thread-safety test.
    new Thread(
            () -> {
              assertThrows(CancellationException.class, future::get);
              successLatch.countDown();
            })
        .start();

                }
              });
      thread.start();
      // we want to wait until each thread is WAITING - one thread waiting inside CacheLoader.load
      // (in startSignal.await()), and the others waiting for that thread's result.
      while (thread.isAlive() && thread.getState() != Thread.State.WAITING) {
        Thread.yield();
      }
    }
    gettersStartedSignal.countDown();