}

    @Override
    public ListIterator<E> listIterator(int index) {
      return delegate().listIterator(index); // manually synchronized
    }

    @Override
    public E remove(int index) {
      synchronized (mutex) {
        return delegate().remove(index);
      }
    }

    @Override
    public E set(int index, E element) {
      synchronized (mutex) {

    }

    @Override
    public ListIterator<E> listIterator(int index) {
      return delegate().listIterator(index); // manually synchronized
    }

    @Override
    public E remove(int index) {
      synchronized (mutex) {
        return delegate().remove(index);
      }
    }

    @Override
    public E set(int index, E element) {
      synchronized (mutex) {

     */
    public synchronized void clear() {
        timeoutTaskList.clear();
    }

    /**
     * Adds a {@link TimeoutTarget}.
     *
     * @param timeoutTarget the target
     * @param timeout the timeout duration
     * @param permanent whether the task is permanent
     * @return the {@link TimeoutTask}
     */

    startTask();
    try {
      command.run();
    } finally {
      endTask();
    }
  }

  @Override
  public boolean isShutdown() {
    synchronized (lock) {
      return shutdown;
    }
  }

  @Override
  public void shutdown() {
    synchronized (lock) {
      shutdown = true;
      if (runningTasks == 0) {
        lock.notifyAll();
      }
    }
  }

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

        ArtifactTransferEvent event = wrap(transferEvent);

        Long transferred;
        synchronized (transfers) {
            transferred = transfers.remove(transferEvent.getResource());
        }
        if (transferred != null) {
            event.setTransferredBytes(transferred);
        }

        synchronized (artifacts) {
            artifacts.remove(transferEvent.getResource());
        }

  fun tearDown() {
    taskQueue.shutdown()
    taskQueue.idleLatch().await(10, TimeUnit.SECONDS)
  }

  @Synchronized fun sentPingCount(): Int = sentPingCount

  @Synchronized fun receivedPingCount(): Int = receivedPingCount

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {

  }

  @Override
  public int size() {
    synchronized (lock) {
      return cachingHashMap.size();
    }
  }

  @Override
  public boolean isEmpty() {
    synchronized (lock) {
      return cachingHashMap.isEmpty();
    }
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Timestamped<V> value;
    synchronized (lock) {
      checkNotNull(key);

   * into user code.
   *
   * @param enqueuedCall a call to enqueue in the synchronized block
   * @param finishedCall a call to finish in the synchronized block
   * @param finishedAsyncCall an async call to finish in the synchronized block
   */
  private fun promoteAndExecute(
    enqueuedCall: AsyncCall? = null,
    finishedCall: RealCall? = null,