*   mutation, which is not an actual risk because we use `synchronized`.
   * - Make `remaining` require a non-null `seq` argument. But this is a bit weird because the
   *   method, while it would avoid the instance field `seq` would still access the instance field
   *   `pos`.
   */

  @Override
  public synchronized int read(CharBuffer target) throws IOException {
    checkNotNull(target);
    checkOpen();

     */
    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();
      }
    }
  }

  private val _failedRoutes = mutableSetOf<Route>()

  val failedRoutes: Set<Route>
    @Synchronized get() = _failedRoutes.toSet()

  /** Records a failure connecting to [failedRoute]. */
  @Synchronized fun failed(failedRoute: Route) {
    _failedRoutes.add(failedRoute)
  }

  /** Records success connecting to [route]. */
  @Synchronized fun connected(route: Route) {
    _failedRoutes.remove(route)
  }

        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());
        }

     */
    public int getMessageCount() {
        synchronized (messagesLock) {
            return messages != null ? messages.size() : 0;
        }
    }

    /**
     * Clears all messages in this session and updates the last accessed timestamp.
     */
    public void clearMessages() {
        synchronized (messagesLock) {
            if (messages != null) {
                messages.clear();

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;

 */
class RecordingCallback : Callback {
  private val responses = mutableListOf<RecordedResponse>()

  @Synchronized
  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {

  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {
      list.clear();
    }
  }

  /** Returns a snapshot of the logged records. */

    enqueueHelper(event, label);
  }

  private void enqueueHelper(Event<L> event, Object label) {
    checkNotNull(event, "event");
    checkNotNull(label, "label");
    synchronized (listeners) {
      for (PerListenerQueue<L> queue : listeners) {
        queue.add(event, label);
      }
    }
  }

  /**