}
            return actor;
        }
    }

    private void stopped(NonBlockingActor actor) {
        synchronized (lock) {
            nonBlockingActors.values().remove(actor);
        }
    }

    private void stopped(BlockingActor actor) {
        synchronized (lock) {
            blockingActors.values().remove(actor);
        }
    }

    private class BlockingActor implements Actor {

  private val _failedRoutes = mutableSetOf<Route>()

  val failedRoutes: Set<Route>
    @Synchronized get() = _failedRoutes.toSet()

  /** Records a failure connecting to [failedRoute]. */
  @Synchronized fun failed(failedRoute: Route) {
    _failedRoutes.add(failedRoute)
  }

  /** Records success connecting to [route]. */
  @Synchronized fun connected(route: Route) {
    _failedRoutes.remove(route)
  }

    }

    @Override
    public synchronized <T> T get(Class<T> serviceType) throws UnknownServiceException {
        if (services.containsKey(serviceType)) {
            return Cast.uncheckedNonnullCast(services.get(serviceType));
        }
        T t = delegate.get(serviceType);
        services.put(serviceType, t);
        return t;
    }

    @Override

        WorkerDaemonClient client = workerDaemonStarter.startDaemon(forkOptions);
        synchronized (lock) {
            allClients.add(client);
        }
        return client;
    }

    public void release(WorkerDaemonClient client) {
        synchronized (lock) {
            if (!client.isFailed()) {
                idleClients.add(client);
            }
        }
    }

    private UserInput pending;
    private boolean finished;

    @Override
    public void startInput() {
        synchronized (lock) {
            pending = null;
            finished = false;
        }
    }

    @Override
    public void putInput(UserInput input) {
        synchronized (lock) {
            if (input == END_OF_INPUT) {
                finished = true;
                lock.notifyAll();

            }
        }
    }

    @Override
    public void close() {
        synchronized (lock) {
            // Allow threads to read anything still buffered
            closed = true;
            lock.notifyAll();
        }
    }

    public void received(byte[] bytes) {
        synchronized (lock) {
            if (!waiting) {
                throw new IllegalStateException();
            }

    @Nullable
    public Object remove(Object key) {
        Object result;
        synchronized (delegate) {
            result = delegate.remove(key);
        }
        reportAccess(key, result);
        reportRemoval(key);
        return result;

    }

    @Override
    public void putAll(Map<?, ?> t) {
        synchronized (delegate) {
            delegate.putAll(t);
        }

			_, err = manager.synchronize(diskInfoProvider, activePodsFunc)

			if err != nil {
				t.Fatalf("Manager should not have an error %v", err)
			}

			// we should not have disk pressure
			if manager.IsUnderDiskPressure() {
				t.Fatalf("Manager should not report disk pressure")
			}

			// synchronize
			_, err = manager.synchronize(diskInfoProvider, activePodsFunc)

    override fun scopeFor(classLoader: ClassLoader?): Pair<ClassLoaderScopeSpec, ClassLoaderRole>? {
        synchronized(lock) {
            return loaders[classLoader]
        }
    }

    override fun childScopeCreated(parentId: ClassLoaderScopeId, childId: ClassLoaderScopeId, origin: ClassLoaderScopeOrigin?) {
        synchronized(lock) {
            if (scopeSpecs.containsKey(childId)) {
                // scope is being reused

        try {
            synchronized (lock) {
                init();
                return communicationAddresses;
            }
        } catch (Exception e) {
            throw new RuntimeException("Could not determine the local IP addresses for this machine.", e);
        }
    }

    public InetAddress getLocalBindingAddress() {
        try {
            synchronized (lock) {
                init();