int max = NbtAddress.NBNS.length;

        if (max == 0) {
            max = 1; /* No WINs, try only bcast addr */
        }

        synchronized (response) {
            while (max-- > 0) {
                try {
                    synchronized (LOCK) {
                        request.nameTrnId = getNextNameTrnId();
                        nid = request.nameTrnId;

            this.cache = new ArrayList<>(maxBuffers);
        }

        @Override
        public synchronized byte[] getBuffer() {
            if (!cache.isEmpty()) {
                return cache.remove(0);
            }
            return new byte[bufferSize];
        }

        @Override
        public synchronized void releaseBuffer(byte[] buf) {
            if (buf != null && cache.size() < maxBuffers) {

     *
     * @return the tree handle implementation
     * @throws CIFSException if a connection error occurs
     */
    protected synchronized SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        return this.handle.ensureTreeConnected();
    }

    @Override
    protected synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        return this.handle.ensureOpen();
    }

    /**

     * @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.

    Multimap<K, V> multimap = synchronizedMultimap(HashMultimap.<K, V>create());
    Collection<V> values = multimap.get(key); // Needn't be in synchronized block
    synchronized (multimap) { // Synchronizing on multimap, not values!
      Iterator<V> i = values.iterator(); // Must be in synchronized block
      while (i.hasNext()) {
        foo(i.next());
      }
    }
  }

  private static void foo(Object unused) {}

    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,

      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(

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

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.
 */

     *
     * @param text the text containing URLs
     * @return the text with replaced URLs
     */
    public String replaceUrls(final String text) {
        if (cachedPathMappingList == null) {
            synchronized (this) {
                if (cachedPathMappingList == null) {
                    init();
                }
            }
        }
        String result = text;