}

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */

     *
     * @param factory The URL stream handler factory.
     */
    public static void setURLStreamHandlerFactory(final URLStreamHandlerFactory factory) {
        synchronized (PROTOCOL_HANDLERS) {
            if (Handler.factory != null) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();

    }

    // gather artifactIds which are not unique so that the respective thread names can be extended with the groupId
    public Set<String> duplicateIds() {
        if (duplicateIds == null) {
            synchronized (this) {
                if (duplicateIds == null) {
                    duplicateIds = projects()
                            .map(MavenProject::getArtifactId)

            }
        }

        public synchronized void recordSuccess(long responseTimeMs) {
            getCurrentBucket().recordSuccess(responseTimeMs);
        }

        public synchronized void recordFailure() {
            getCurrentBucket().recordFailure();
        }

        public synchronized WindowMetrics getMetrics() {
            long now = System.currentTimeMillis();

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

package okhttp3

import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLSession

class RecordingHostnameVerifier : HostnameVerifier {
  @JvmField
  val calls: MutableList<String> = mutableListOf()

  @Synchronized override fun verify(
    hostname: String,
    session: SSLSession,
  ): Boolean {
    calls.add("verify $hostname")
    return true
  }

   */
  public static TesterRequirements getTesterRequirements(Class<?> testerClass)
      throws ConflictingRequirementsException {
    synchronized (classTesterRequirementsCache) {
      TesterRequirements requirements = classTesterRequirementsCache.get(testerClass);
      if (requirements == null) {
        requirements = buildTesterRequirements(testerClass);

            }
        }
        obj = getCachedAddress(name);
        if (obj == null) {
            synchronized (LOOKUP_TABLE) {
                LOOKUP_TABLE.put(name, name);
            }
        }

        return obj;
    }

    private static void updateLookupTable(final Name name) {
        synchronized (LOOKUP_TABLE) {
            LOOKUP_TABLE.remove(name);
            LOOKUP_TABLE.notifyAll();
        }

            return hashAlgorithm;
        }

        public byte[] getCurrentHash() {
            synchronized (hashLock) {
                return currentHash.clone();
            }
        }

        public void updateHash(byte[] newHash) {
            synchronized (hashLock) {
                if (newHash != null && newHash.length == currentHash.length) {

    @SuppressWarnings("SynchronizeOnNonFinalField")
    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (lock) {
          if (!initialized) {
            T t = delegate.get();
            value = t;
            initialized = true;
            return t;
          }
        }
      }