prev = x;
      }
    }
  }

  /** compareAndSet in one thread enables another waiting for value to succeed */
  public void testCompareAndSetInMultipleThreads() throws InterruptedException {
    AtomicDoubleArray a = new AtomicDoubleArray(1);
    a.set(0, 1.0);
    Thread t =
        newStartedThread(
            new CheckedRunnable() {
              @Override

     * Set to -1 to disable automatic cleanup.
     */
    @Required
    @Min(-1)
    @Max(1000)
    @ValidateTypeFailure
    public Integer dayForCleanup;

    /**
     * Number of threads to use for crawling operations.
     * Higher values increase crawling speed but consume more resources.
     */
    @Required
    @Min(0)
    @Max(100)
    @ValidateTypeFailure
    public Integer crawlingThreadCount;

    }
  }

  /** Wait for the given thread to reach the {@link State#TIMED_WAITING} thread state. */
  @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
  void awaitTimedWaiting(Thread thread) {
    while (true) {
      switch (thread.getState()) {
        case BLOCKED:
        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;

 * wherever possible.
 *
 * <p>A {@code UnicodeEscaper} instance is required to be stateless, and safe when used concurrently
 * by multiple threads.
 *
 * <p>Popular escapers are defined as constants in classes like {@link
 * com.google.common.html.HtmlEscapers} and {@link com.google.common.xml.XmlEscapers}. To create

     */
    public CrawlJob dataConfigIds(final String[] dataConfigIds) {
        this.dataConfigIds = dataConfigIds;
        return this;
    }

    /**
     * Sets the hot thread monitoring interval for performance analysis.
     * Hot threads help identify performance bottlenecks in the crawler process.
     *
     * @param hotThreadInterval monitoring interval in seconds, -1 to disable

 * documented. Exceptions to this are {@link #containsKey}, {@link #size}, {@link #isEmpty}, {@link
 * #asMap}, and {@link #toString}.
 *
 * <p>Instances of this class may be used by multiple threads concurrently. All operations are
 * atomic unless otherwise noted.
 *
 * <p>Instances of this class are serializable if the keys are serializable.
 *

                                 * sent. Unfortunately calling disconnect() doesn't always
                                 * actually shutdown the connection before other threads
                                 * have committed themselves (e.g. InterruptTest example).
                                 */
                                try {

*p += i
</pre>

<p>
If <code>i</code> and <code>*p</code> start equal to 2,
the original code does <code>*p = 3</code>,
so a racing thread can read only 2 or 3 from <code>*p</code>.
The rewritten code does <code>*p = 1</code> and then <code>*p = 3</code>,
allowing a racing thread to read 1 as well.
</p>

<p>
Note that all these optimizations are permitted in C/C++ compilers:

// ops.
TF_CAPI_EXPORT extern void TFE_ContextClearCaches(TFE_Context* ctx);

// Sets a thread-local device placement policy. After this call, other calls to
// TFE_Execute in the same thread will use the device policy specified here
// instead of the device policy used to construct the context. This has no
// effect on the device policy used by other program threads.
TF_CAPI_EXPORT extern void TFE_ContextSetThreadLocalDevicePlacementPolicy(

    hand it off to another thread to write to it after `writeTo` returns.

    The `EventListener` may now see requests and responses interleaved in ways not previously
    permitted. For example, a listener may receive `responseHeadersStart()` followed by
    `requestBodyEnd()`, both on the same call. Such events may be triggered by different threads
    even for a single call.