* contract.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 * @since 12.0
 */
@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>

 * contract.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be
 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 * @since 12.0
 */
@GwtIncompatible
public abstract class ForwardingNavigableMap<K extends @Nullable Object, V extends @Nullable Object>

 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that
 * modifications are visible, synchronize access to the table. Unlike other {@code Table}
 * implementations, synchronization is unnecessary between a thread that writes to one cell and a

        // start
        AccessTimeoutTarget accessTimeoutTarget = null;
        TimeoutTask accessTimeoutTask = null;
        if (accessTimeout != null) {
            accessTimeoutTarget = new AccessTimeoutTarget(Thread.currentThread());
            accessTimeoutTask = TimeoutManager.getInstance().addTimeoutTarget(accessTimeoutTarget, accessTimeout, false);
        }

        final ExtractData data = new ExtractData();

   *
   * Since these fields are non-final that means that TimeoutFuture is not being 'safely published',
   * thus a motivated caller may be able to expose the reference to another thread that would then
   * call cancel() and be unable to cancel the delegate.
   * There are a number of ways to solve this, none of which are very pretty, and it is currently

 * methods to add, remove, clear, and retrieve data from these structures.
 *
 * <p>The class is thread-safe due to the use of {@code synchronized} keyword on methods that
 * modify the internal data structures. The internal maps are also declared as {@code volatile}
 * to ensure visibility of changes across threads.
 *
 * <p>The class also provides methods to manage URL patterns for inclusion and exclusion, which

                }
            }

            out.write(sbuf, 0, 4 + n);
            out.flush();
            /* Note the Transport thread isn't running yet so we can
             * read from the socket here.
             */
            if (peekKey() == null) { /* try to read header */
                throw new IOException("transport closed in negotiate");
            }

            + "^\\s*data:|" //
            + "^\\s*android-app:|" //
            + "^\\s*ios-app:|" //
            + "^\\s*callto:", Pattern.CASE_INSENSITIVE);

    /** Thread-local XPathAPI instance for thread-safe XPath operations. */
    private final ThreadLocal<XPathAPI> xpathAPI = new ThreadLocal<>();

    @Override
    public ResultData transform(final ResponseData responseData) {

 *  New: Share threads more aggressively between OkHttp's HTTP/2 connections, connection pool,
    web sockets, and cache. OkHttp has a new internal task runner abstraction for managed task
    scheduling. In your debugger you will see new thread names and more use of daemon threads.

 *  Fix: Don't drop callbacks on unexpected exceptions. When an interceptor throws an unchecked

    call: Call,
    delay: Long,
  ): Thread {
    val thread =
      object : Thread("canceler") {
        override fun run() {
          try {
            sleep(delay)
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          call.cancel()
        }
      }
    thread.start()
    return thread
  }