int exitCode = process.waitFor();
                    out.join();
                    err.join();
                    if (exitCode != 0) {
                        shellContext.logger.error("Shell command exited with code " + exitCode);
                    }
                } catch (Exception e) {
                    saveException(e);
                }
            }
        }

                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.cancel(true);
              if (!future.isDone()) {
                errorMessage.set("Cancel call exited before future was complete.");
              }

                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.cancel(true);
              if (!future.isDone()) {
                errorMessage.set("Cancel call exited before future was complete.");
              }

```sh
docker ps -a
```

`-a` flag makes sure you get all the containers (Created, Running, Exited). Then identify the `Container ID` from the output.

### Starting and Stopping Containers

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

      throws InterruptedException {
    while (!isThreadBlockedOnInstanceOf(t, blocker)) {
      if (t.getState() == Thread.State.TERMINATED) {
        throw new RuntimeException("Thread " + t + " exited unexpectedly");
      }
      Thread.sleep(1);
    }
  }

  private static boolean isThreadBlockedOnInstanceOf(Thread t, Class<?> blocker) {

       *
       * - in the "reentrant submit" case of `execute` (in which case we must have started running a
       *   user task -- which means that we already got past this code (or else we exited early
       *   above))
       */
      // Unconditionally set; there is no risk of throwing away a queued task from another thread,

       *
       * - in the "reentrant submit" case of `execute` (in which case we must have started running a
       *   user task -- which means that we already got past this code (or else we exited early
       *   above))
       */
      // Unconditionally set; there is no risk of throwing away a queued task from another thread,

		if rec := recover(); rec != nil {
			gridLogIf(ctx, fmt.Errorf("handleMessages: panic recovered: %v", rec))
			debug.PrintStack()
		}
		if debugPrint {
			fmt.Println("handleMessages: write goroutine exited")
		}
		cancel(ErrDisconnected)
		c.connChange.L.Lock()
		if atomic.CompareAndSwapUint32((*uint32)(&c.state), StateConnected, StateConnectionError) {
			c.connChange.Broadcast()
		}
		c.disconnected()

    return new Exiter(Runtime.getRuntime()::exit);
  }

  @VisibleForTesting
  interface RuntimeWrapper {
    void exit(int status);
  }

  @VisibleForTesting
  static final class Exiter implements UncaughtExceptionHandler {
    private static final LazyLogger logger = new LazyLogger(Exiter.class);

    private final RuntimeWrapper runtime;

    Exiter(RuntimeWrapper runtime) {

 */

package com.google.common.util.concurrent;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

import com.google.common.util.concurrent.UncaughtExceptionHandlers.Exiter;
import com.google.common.util.concurrent.UncaughtExceptionHandlers.RuntimeWrapper;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author Gregory Kick
 */
@NullUnmarked