handler.start(11, {})
        handler.start(12, {})

        then:
        2 * factory.create(_ as String) >> Mock(ManagedExecutor)
    }

    def "cannot start contention handling when the handler was stopped"() {
        handler.stop()

        when:
        handler.start(10, {})

        then:
        thrown(IllegalStateException)
    }

// Before Go 1.23, the garbage collector did not recover
// timers that had not yet expired or been stopped, so code often
// immediately deferred t.Stop after calling NewTimer, to make
// the timer recoverable when it was no longer needed.
// As of Go 1.23, the garbage collector can recover unreferenced
// timers, even if they haven't expired or been stopped.
// The Stop method is no longer necessary to help the garbage collector.

        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("ThumbnailGenerator is stopped.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("ThumbnailGenerator is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;
        } catch (final Throwable t) {

	ref [numSig]int64
	// Map channels to signals while the channel is being stopped.
	// Not a map because entries live here only very briefly.
	// We need a separate container because we need m to correspond to ref
	// at all times, and we also need to keep track of the *handler
	// value for a channel being stopped. See the Stop function.
	stopping []stopping
}

type stopping struct {
	c chan<- os.Signal

        state(busy, numDaemons - busy)
    }

    void idle() {
        idle(numDaemons)
    }

    void idle(int idle) {
        state(numDaemons - idle, idle)
    }

    void stopped() {
        numDaemons = 0
        state(0, 0)
    }

    void state(int busy, int idle) {
        state(new DaemonsState(busy, idle))
    }

    void state(DaemonsState checkpointState) {

    def fixture = new TestDeploymentFixture()

    def setup() {
        fixture.writeToProject(projectDir)
        buildTimeout = 30
    }

    def "deployment is stopped when continuous build is cancelled" () {
        when:
        runBuild(["runDeployment"]) {
            succeeds()
            def key = fixture.keyFile.text
            fixture.assertDeploymentIsRunning(key)

            }
            if (numIncompatible > 0) {
                reasons.add(numIncompatible + " incompatible");
            }
            if (numStopped > 0) {
                reasons.add(numStopped + " stopped");
            }

            return STARTING_DAEMON_MESSAGE + ", "
                + Joiner.on(" and ").join(reasons) + " Daemon" + (totalUnavailableDaemons > 1 ? "s" : "")
                + NOT_REUSED_MESSAGE;

     * complete. Note that the action may have completed by the time this method returns.
     *
     * @throws IllegalStateException When this connection has been stopped or is stopping.
     */
    <T> void run(ConsumerAction<? extends T> action, ResultHandlerVersion1<? super T> handler);

    /**
     * Stops this connection, blocking until all operations on the connection have completed.

        given:
        actor.stop()

        when:
        proxy.doStuff('param')

        then:
        IllegalStateException e = thrown()
        e.message == 'This actor has been stopped.'
    }

    def cannotDispatchToNonBlockingActorAfterItHasBeenStopped() {
        def actor = factory.createActor(target)
        def proxy = actor.getProxy(TargetObject.class)

        given:

                }
            }
        }
        drainTo.addAll(queue);
        queue.clear();
    }

    public void stop() {
        owner.stopped(this);
    }