* @run main/othervm/timeout=1000 AutoShutdown

import java.lang.ref.WeakReference;

import java.util.Arrays;

import java.util.concurrent.ConcurrentLinkedQueue;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Executor;

import java.util.concurrent.TimeUnit;

import static java.util.concurrent.Executors.defaultThreadFactory;

import static java.util.concurrent.Executors.newFixedThreadPool;

import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;

import static java.util.concurrent.Executors.newSingleThreadExecutor;

    static void await(CountDownLatch latch) throws InterruptedException {

        if (!latch.await(100L, TimeUnit.SECONDS))

            throw new AssertionError("timed out waiting for latch");

        final Executor[] executors = {

            newSingleThreadExecutor(),

            newSingleThreadExecutor(defaultThreadFactory()),

            // TODO: should these executors also auto-shutdown?

            //newFixedThreadPool(1),

            //newSingleThreadScheduledExecutor(),

            //newSingleThreadScheduledExecutor(defaultThreadFactory()),

        final ConcurrentLinkedQueue<WeakReference<Thread>> poolThreads

            = new ConcurrentLinkedQueue<>();

        final CountDownLatch threadStarted

            = new CountDownLatch(executors.length);

        final CountDownLatch pleaseProceed

            = new CountDownLatch(1);

        Runnable task = new Runnable() { public void run() {

            try {

                poolThreads.add(new WeakReference<>(Thread.currentThread()));

                threadStarted.countDown();

                await(pleaseProceed);

            } catch (Throwable t) { unexpected(t); }

        }};

        for (Executor executor : executors)

            executor.execute(task);

        await(threadStarted);

        pleaseProceed.countDown();

        Arrays.fill(executors, null);   // make executors unreachable

        boolean done = false;

        for (long timeout = 1L; !done && timeout <= 128L; timeout *= 2) {

            System.gc();

            done = true;

            for (WeakReference<Thread> ref : poolThreads) {

                Thread thread = ref.get();

                if (thread != null) {

                    TimeUnit.SECONDS.timedJoin(thread, timeout);

                    if (thread.isAlive())

                        done = false;

                }

            }

        if (!done)

            throw new AssertionError("pool threads did not terminate");