* ...
   * Map<C, V> row = table.row(rowKey);  // Needn't be in synchronized block
   * ...
   * synchronized (table) {  // Synchronizing on table, not row!
   *   Iterator<Entry<C, V>> i = row.entrySet().iterator(); // Must be in synchronized block
   *   while (i.hasNext()) {
   *     foo(i.next());
   *   }
   * }
   * }</pre>
   *

        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);
            }
        }
    }

    public synchronized static void init(WarningMode warningMode, BuildOperationProgressEventEmitter buildOperationProgressEventEmitter, Problems problemsService, ProblemStream problemStream) {
        DEPRECATED_FEATURE_HANDLER.init(warningMode, buildOperationProgressEventEmitter, problemsService, problemStream);
    }

    public synchronized static void reset() {
        DEPRECATED_FEATURE_HANDLER.reset();

    private TestClassProcessor processor;
    private TestResultProcessor resultProcessor;

    /**
     * Note that the state object is not synchronized and not thread-safe.  Any modifications to the
     * the state should ONLY be made inside the main thread or inside a command passed to the run queue
     * (which will execute on the main thread).
     */

        void queueIncoming(Message message) {
            synchronized (lock) {
                receiveQueue << message
                lock.notifyAll()
            }
        }

        void queueBroken(Throwable failure = new RuntimeException()) {
            queueIncoming(new Failure(failure))
        }

        Message receive() {
            synchronized (lock) {
                while (receiveQueue.empty) {

            this.originalPath = originalPath;
            this.transformedJarPath = transformedJarPath;
        }

        @Override
        @Nullable
        public synchronized byte[] loadTransformedClass(String className) throws IOException {
            JarFile jarFile = getJarFileLocked();
            // From this point it is safe to load the bytes even if somebody attempts to close the replacer.

            this.pluginDeclarations = new LinkedHashSet<>();
            this.pluginIssues = new HashMap<>();
            this.mojoIssues = new HashMap<>();
        }

        private synchronized void reportPluginIssue(
                IssueLocality issueLocality, String pluginDeclaration, String issue) {
            if (pluginDeclaration != null) {
                pluginDeclarations.add(pluginDeclaration);

	// We ensure this is safe by stopping the world, which acts a global barrier on almost
	// every M, and explicitly synchronize with any other Ms that could be running concurrently
	// with us. Today, there are only two such cases:
	// - sysmon, which we synchronized with by acquiring sysmonlock.
	// - goroutines exiting syscalls, which we synchronize with via trace.exitingSyscall.
	//

            if (name.startsWith(scriptSource.getClassName())) {
                // Synchronized to avoid multiple threads attempting to define the same class on a lookup miss
                synchronized (this) {
                    Class<?> cl = findLoadedClass(name);
                    if (cl == null) {
                        cl = findClass(name);

        toArrayCalled = true;
        return super.toArray(a);
      }
    }

    // Test that toArray() is used to make a defensive copy in copyOf(), so concurrently modified
    // synchronized collections can be safely copied.
    TestArrayList<String> toCopy = new TestArrayList<>();
    ImmutableSortedMultiset<String> unused =
        ImmutableSortedMultiset.copyOf(Ordering.natural(), toCopy);