}

    char[] chars = string.toCharArray();
    int spread = 1;

    // This unusual loop comes from extensive benchmarking
    OUT:
    while (true) {
      pos++;
      while (true) {
        if (pos == chars.length) {
          break OUT;
        }
        if (matches(chars[pos])) {
          break;
        }
        chars[pos - spread] = chars[pos];
        pos++;
      }
      spread++;

     * look at table entries if it is 0.
     *
     * - All (synchronized) write operations should write to the "count" field after structurally
     * changing any bin. The operations must not take any action that could even momentarily
     * cause a concurrent read operation to see inconsistent data. This is made easier by the

* Copy and display source location prominently on Kubernetes instances ([#27840](https://github.com/kubernetes/kubernetes/pull/27840), [@zmerlynn](https://github.com/zmerlynn))
* AWS/GCE: Spread PetSet volume creation across zones, create GCE volumes in non-master zones ([#27553](https://github.com/kubernetes/kubernetes/pull/27553), [@justinsb](https://github.com/justinsb))

        }

        // Read partial content
        try (InputStream in = file.getInputStream()) {
            byte[] buffer = new byte[10];
            int bytesRead = in.read(buffer);
            assertEquals(10, bytesRead, "Should read requested bytes");
            assertEquals("0123456789", new String(buffer, 0, bytesRead, "UTF-8"));

            // Read next chunk
            bytesRead = in.read(buffer);

                }
              });
      thread.start();
      // we want to wait until each thread is WAITING - one thread waiting inside CacheLoader.load
      // (in startSignal.await()), and the others waiting for that thread's result.
      while (thread.isAlive() && thread.getState() != Thread.State.WAITING) {
        Thread.yield();
      }
    }
    gettersStartedSignal.countDown();

	buf := make([]byte, 1)
	if _, err := b.Read(nil); err != nil {
		t.Fatalf("1st nil Read = %v; want nil", err)
	}
	if _, err := b.Read(buf); err != errFake {
		t.Fatalf("1st Read = %v; want errFake", err)
	}
	if _, err := b.Read(nil); err != nil {
		t.Fatalf("2nd nil Read = %v; want nil", err)
	}
	if _, err := b.Read(buf); err != nil {
		t.Fatalf("3rd Read with buffer = %v; want nil", err)
	}

    override fun writeTo(sink: BufferedSink) {
      try {
        var i = 0
        while (i < contentLength()) {
          sink.write(chunk!!)
          sink.flush()
          Thread.sleep(100)
          i += chunk.size
        }
      } catch (e: IOException) {
        ioe = e
      } catch (e: InterruptedException) {
        throw RuntimeException(e)
      }
    }
  }

crawler.system.monitor.interval=60
# Whether to ignore idle threads in hot thread monitoring.
crawler.hotthread.ignore_idle_threads=true
# Interval for hot thread monitoring (e.g., 500ms).
crawler.hotthread.interval=500ms
# Number of snapshots for hot thread monitoring.
crawler.hotthread.snapshots=10
# Number of threads for hot thread monitoring.
crawler.hotthread.threads=3
# Timeout for hot thread monitoring (e.g., 30s).
crawler.hotthread.timeout=30s

   * higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the cache
   * at a time, but since read operations and cache loading computations can proceed concurrently,

        /*
         * Note the Transport thread isn't running yet so we can
         * read from the socket here.
         */
        try {
            this.socket.setSoTimeout(this.transportContext.getConfig().getConnTimeout());
            if (peekKey() == null) { /* try to read header */
                throw new IOException("transport closed in negotiate");
            }