synchronized (lock) {
                stopped = true;
            }
            stopped(this);
        }

        @Override
        public void dispatch(MethodInvocation message) {
            synchronized (lock) {
                if (stopped) {
                    throw new IllegalStateException("This actor has been stopped.");
                }
                dispatch.dispatch(message);

        then:
        noExceptionThrown()
    }

    def "throws exception when attempting to use service after it has stopped"() {
        when:
        lifecycle.stop()
        lifecycle.use { }

        then:
        IllegalStateException e = thrown()
        e.message == 'Cannot use [service] as it has been stopped.'
    }

    def "throws exception when attempting to use service after stop has been requested"() {
        when:

package org.gradle.launcher.daemon.server;

/**
 * Indicates the state of the daemon when it stops doing work.
 */
public enum DaemonStopState {
    /**
     * Daemon was stopped cleanly and all work stopped.
     */
    Clean,
    /**
     * Daemon could not be stopped cleanly and some work may still be running.
     */
    Forced

	defer timer.Stop()
	for {
		stopped := func() bool {
			pr.mux.Lock()
			defer pr.mux.Unlock()
			for pr.waiting == 0 && !pr.stopped {
				pr.cond.Wait()
			}
			return pr.stopped
		}()
		if stopped {
			return
		}

		select {
		case <-timer.C():
			shouldRequest := func() bool {
				pr.mux.Lock()
				defer pr.mux.Unlock()
				return pr.waiting > 0 && !pr.stopped
			}()
			if !shouldRequest {

        }

        private boolean moreMessagesToSend() {
            return ableToSend && !(stopped && queue.isEmpty());
        }

        private Object getNextEvent() {
            try {
                return queue.poll(10, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                stopped = true;
                return null;
            }
        }

        0       | 1               | 0          | ["1 incompatible"]
        1       | 0               | 0          | ["1 busy"]
        0       | 0               | 1          | ["1 stopped"]
        1       | 2               | 4          | ["1 busy", "2 incompatible", "4 stopped"]
    }

    def "starting message contains subsequent builds message given no unavailable daemons"() {
        given:

            }
        }

        private void onAfterTimeoutCheck() {
            synchronized (lock) {
                if (!stopped) {
                    slowStop = true;
                    doAsPartOfBuildOperation(() -> {
                        LOGGER.warn("Timed out {} has not yet stopped.", workUnitDescription.getDisplayName());

                        if (logStacktraceTimer.hasExpired()) {

                socket.send(packet);
            } catch (IOException e) {
                if (!stopped) {
                    LOGGER.debug("Failed to confirm lock release to Gradle process at port {} for lock with id {}.", packet.getPort(), lockId);
                }
            }
        }
    }

    public void stop() {
        stopped = true;
        socket.close();
    }

    public int getPort() {

        } finally {
            LOGGER.debug("Stopped deployment handles");
            stopped = true;
            deployments.clear();
            lock.unlock();
        }
        pendingChangesManager.removeListener(this);
    }

    private void failIfStopped() {
        if (stopped) {

                LOGGER.debug("Requesting daemon {} stop now", connection.getDaemon());
                boolean stopped = stopDispatcher.dispatch(connection, new Stop(idGenerator.generateId(), connection.getDaemon().getToken()));
                if (stopped) {
                    numStopped++;
                }
            } finally {
                connection.stop();
            }