completionLatch.await();
      synchronized (this) {
        return ImmutableList.copyOf(stateHistory);
      }
    }

    @Override
    public synchronized void starting() {
      assertTrue(stateHistory.isEmpty());
      assertThat(service.state()).isNotEqualTo(State.NEW);
      stateHistory.add(State.STARTING);
    }

    @Override
    public synchronized void running() {

     *
     * @param props the properties to use for initialization
     * @throws CIFSException if the singleton context is already initialized or there is an error during initialization
     */
    public static synchronized final void init(final Properties props) throws CIFSException {
        if (INSTANCE != null) {
            throw new CIFSException("Singleton context is already initialized");
        }

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.truth.Truth.assertThat;

import com.google.common.collect.Synchronized.SynchronizedCollection;
import com.google.common.collect.Synchronized.SynchronizedSet;
import com.google.common.testing.SerializableTester;
import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

    }

    /**
     * Establishes RDMA connection to the remote server.
     *
     * @throws IOException if connection fails
     */
    public void connectRdma() throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null && rdmaConnection.isConnected()) {
                return;
            }

            try {
                rdmaConnection =

     * @param a the authenticator to set as default
     */

    public synchronized static void setDefault(final NtlmAuthenticator a) {
        if (auth != null) {
            return;
        }
        auth = a;
    }

    /**
     * Gets the URL that is requesting authentication.

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
import okhttp3.internal.assertionsEnabled

/**
 * Marker interface for objects that use the JVM's `synchronized` mechanism and the related
 * `wait()` and `notify()` functions.
 *
 * The Lockable interface is particularly handy because it ensures we lock the right `this` when
 * there are multiple `this` objects in scope.
 */

      hitCount++
    }
  }

  @Synchronized internal fun trackConditionalCacheHit() {
    hitCount++
  }

  @Synchronized fun networkCount(): Int = networkCount

  @Synchronized fun hitCount(): Int = hitCount

  @Synchronized fun requestCount(): Int = requestCount

  private inner class RealCacheRequest(

    static LogStream log = LogStream.getInstance();
    static HashMap dfsRoots = null;

    static synchronized SmbTransport getSmbTransport(final UniAddress address, final int port) {
        return getSmbTransport(address, port, LADDR, LPORT, null);
    }

    static synchronized SmbTransport getSmbTransport(final UniAddress address, final int port, final InetAddress localAddr,

    // Lock while we check state. We must maintain the lock while adding the new pair so that
    // another thread can't run the list out from under us. We only add to the list if we have not
    // yet started execution.
    synchronized (lock) {
      if (!executed) {
        runnables = new RunnableExecutorPair(runnable, executor, runnables);
        return;
      }
    }

     * Registers a CrawlerClientFactory with this creator.
     * All existing client mappings will be loaded into the new factory.
     * @param crawlerClientFactory The CrawlerClientFactory to register.
     */
    public synchronized void register(final CrawlerClientFactory crawlerClientFactory) {
        clientMap.entrySet().stream().forEach(e -> load(crawlerClientFactory, e.getKey(), e.getValue()));
        clientFactoryList.add(crawlerClientFactory);