* The specific problem we had was unsafe reads of lastEntryReturnedBySomeIterator. (To fix the
     * problem, we've since marked that field as volatile.)
     *
     * When MapIteratorCache is used from Immutable* classes, the TSAN failure doesn't indicate a
     * real problem: The Entry objects are ImmutableMap entries, whose fields are all final and thus

  private static final class CloseableList extends IdentityHashMap<AutoCloseable, Executor>
      implements Closeable {
    private final DeferredCloser closer = new DeferredCloser(this);
    private volatile boolean closed;
    private volatile @Nullable CountDownLatch whenClosed;

    <V extends @Nullable Object, U extends @Nullable Object>
        ListenableFuture<U> applyClosingFunction(

    /** Timestamp when the authentication was created */
    private long authenticationTimestamp = System.currentTimeMillis();
    /** Flag to track if this authenticator has been closed */
    private volatile boolean closed = false;

    /**
     * Construct anonymous credentials
     */
    public NtlmPasswordAuthenticator() {
        this(AuthenticationType.NULL);
    }

    /**

     */
    protected int byteCount;
    /**
     * Tree identifier for the connected share.
     */
    protected int tid = 0xFFFF;
    private boolean useUnicode, forceUnicode, extendedSecurity;
    private volatile boolean received;
    private int signSeq;
    private boolean verifyFailed;
    /**
     * Path associated with this SMB message.
     */
    protected String path;
    /**

Here's how the 386 runtime defines the 64-bit atomic load function.
</p>

<pre>
// uint64 atomicload64(uint64 volatile* addr);
// so actually
// void atomicload64(uint64 *res, uint64 volatile *addr);
TEXT runtime·atomicload64(SB), NOSPLIT, $0-12
	MOVL	ptr+0(FP), AX
	TESTL	$7, AX
	JZ	2(PC)
	MOVL	0, AX // crash with nil ptr deref
	LEAL	ret_lo+4(FP), BX

   * Keeps track of metadata like the number of hash table bits and modifications of this data
   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note
   * that we choose not to make this volatile, so we do less of a "best effort" to track such
   * errors, for better performance.
   *
   * <p>For a new instance, where the arrays above have not yet been allocated, the value of {@code

			secretKey:          credentials.SecretKey,
			expectedRespStatus: http.StatusBadRequest,
			shouldPass:         false,
		},
		// Test case - 2.
		// Setting a non-existent bucket.
		{
			bucket:             "volatile-bucket-1",
			prefix:             "",
			keyMarker:          "",
			uploadIDMarker:     "",
			delimiter:          "",
			maxUploads:         "0",
			accessKey:          credentials.AccessKey,

    /** Helper for managing content length limits */
    @Resource
    protected ContentLengthHelper contentLengthHelper;

    /**
     * The FTP authentication holder.
     */
    protected volatile FtpAuthenticationHolder ftpAuthenticationHolder;

    /**
     * The FTP client configuration.
     */
    protected FTPClientConfig ftpClientConfig;

    /**
     * The queue of FTPClient instances.

     * Hash function for generating IDs.
     */
    protected static final HashFunction murmur3Hash = Hashing.murmur3_128(0);

    /**
     * FesenClient instance.
     */
    @Resource
    protected volatile FesenClient fesenClient;

    /**
     * Index name.
     */
    protected String index;

    /**
     * Scroll timeout in milliseconds.
     */
    protected int scrollTimeout = 60000;

  private static final class CloseableList extends IdentityHashMap<AutoCloseable, Executor>
      implements Closeable {
    private final DeferredCloser closer = new DeferredCloser(this);
    private volatile boolean closed;
    private volatile @Nullable CountDownLatch whenClosed;

    <V extends @Nullable Object, U extends @Nullable Object>
        ListenableFuture<U> applyClosingFunction(