* As such, this field must be cleared before every map mutation.
   *
   * Note about volatile: volatile doesn't make it safe to read from a mutable graph in one thread
   * while writing to it in another. All it does is help with _reading_ from multiple threads
   * concurrently. For more information, see AbstractNetworkTest.concurrentIteration.
   */

    }

    private static void interruptThreadSafely(final QueryThread thread) {
        try {
            thread.interrupt();
        } catch (final SecurityException e) {
            log.error("Security exception interrupting thread", e);
        }
    }

    private static void joinThread(final Thread thread) {
        try {
            thread.join();
        } catch (final InterruptedException e) {

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may
   * proceed to read the response body with [Response.body]. The response is still live until its
   * response body is [closed][ResponseBody]. The recipient of the callback may consume the response
   * body on another thread.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not

                try {
                    // Invalidate any cached read data
                    // This would typically clear file's internal read buffers
                    // For now, we log the action as the actual implementation
                    // depends on SmbFile's internal caching mechanism
                    log.info("Invalidated read cache for: {}", path);
                } catch (Exception e) {

    assertThat(inputStream.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    assertThat(inputStream.read()).isEqualTo('D'.code)
    assertThat(inputStream.read()).isEqualTo('E'.code)
    assertThat(inputStream.read()).isEqualTo('F'.code)
    assertThat(inputStream.read()).isEqualTo(-1)

 * currently supporting Kryo and JavaBin serialization formats. The serializer
 * type is determined by the crawler data serializer configuration.
 * </p>
 * <p>
 * The class is thread-safe and uses ThreadLocal to maintain Kryo instances
 * per thread to avoid synchronization overhead.
 * </p>
 *
 */
public class DataSerializer {

    /** Logger for this class. */

        final int threadCount = 10;
        Thread[] threads = new Thread[threadCount];

        // Create threads that access password
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {
                    Thread.sleep((long) (Math.random() * 10));
                    if (index == threadCount - 1) {

        entry.updateChild("file1.txt", 1024L, 1000L, false, 0x20, 500L, 800L);
        entry.markComplete();

        // Break lease with loss of read cache
        int newState = Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING; // Lost read cache
        directoryLeaseManager.handleDirectoryLeaseBreak(leaseKey, newState);

        // Cache should be invalidated
        assertFalse(entry.isComplete());

          /* Someone beat us to it! Trying again...
           *
           * Technically this loop not guaranteed to terminate, so theoretically (extremely
           * unlikely) this thread might starve, but even then, there is always going to be another
           * thread doing progress here.
           */
        }
      }
    }
  }

  /**

                }
            }

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