Object obj;

        synchronized (LOOKUP_TABLE) {
            if (!LOOKUP_TABLE.containsKey(name)) {
                LOOKUP_TABLE.put(name, name);
                return null;
            }
            while (LOOKUP_TABLE.containsKey(name)) {
                try {
                    LOOKUP_TABLE.wait();
                } catch (final InterruptedException e) {}
            }
        }

        return EventListener.NONE;
      }
    }
  };

  ...
}
```

### Events with Failures

When an operation fails, a failure method is called. This is `connectFailed()` for failures while building a connection to the server, and `callFailed()` when the HTTP call fails permanently. When a failure happens it is possible that a `start` event won’t have a corresponding `end` event.

      }
    }
  }

  private fun readAndWriteFrames() {
    check(socket == null)
    val socket = serverSocket!!.accept()!!
    this.socket = socket

    // Bail out now if this instance was closed while waiting for the socket to accept.
    synchronized(this) {
      if (executor.isShutdown) {
        socket.close()
        return
      }
    }
    val outputStream = socket.getOutputStream()

   * #remove} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardRemove(@Nullable Object object) {
    Iterator<E> iterator = iterator();
    while (iterator.hasNext()) {
      if (Objects.equals(iterator.next(), object)) {
        iterator.remove();
        return true;
      }
    }
    return false;
  }

  /**

      return of(first);
    }

    Set<E> delegate = Sets.newLinkedHashSet();
    delegate.add(checkNotNull(first));
    do {
      delegate.add(checkNotNull(elements.next()));
    } while (elements.hasNext());

    return unsafeDelegate(delegate);
  }

  // Factory methods that skips the null checks on elements, only used when
  // the elements are known to be non-null.

   * #remove} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardRemove(@Nullable Object object) {
    Iterator<E> iterator = iterator();
    while (iterator.hasNext()) {
      if (Objects.equals(iterator.next(), object)) {
        iterator.remove();
        return true;
      }
    }
    return false;
  }

  /**

 * support running in that runtime.
 *
 * Some projects have a strict set of runtimes they must support. For example, a
 * plugin that only runs in the daemon would declare the daemon as a target runtime,
 * while a worker action that executes in a worker must declare that it executes in
 * a worker.
 *
 * However, a shared library used by both daemon and worker actions does not necessarily

            comparator);

    return new AbstractIterator<C>() {
      @Nullable C lastValue;

      @Override
      protected @Nullable C computeNext() {
        while (merged.hasNext()) {
          C next = merged.next();
          boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0;

          // Keep looping till we find a non-duplicate value.

        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("Interrupted while shutting down cleanup scheduler", e);
        }

        log.info("Authentication rate limiter closed");
    }

    /**
     * Per-account attempt tracking
     */

     */
    public void checkForLeaks() {
        if (!leakDetectionEnabled) {
            return;
        }

        // Process phantom references to detect leaks
        Reference<?> ref;
        while ((ref = referenceQueue.poll()) != null) {
            handlePhantomReference(ref);
        }

        // Check for old unclosed resources
        long now = System.currentTimeMillis();