byte[] payload = new byte[] { 1, 2, 3, 4 };

        w.start();

        // Wait until writer thread signals readiness
        synchronized (w) {
            long deadline = System.currentTimeMillis() + 2000;
            while (!w.isReady() && System.currentTimeMillis() < deadline) {
                w.wait(10);
            }
            assertTrue(w.isReady(), "WriterThread should be ready to accept work");

            fail(); // Time Out
        }

        logger.info("Crawler is running");
        count = 0;
        isRunning = true;
        sleepTime = 100; // Reset to 100ms for termination wait

        // Wait until the crawler terminates (with exponential backoff)
        while (count < 3000 && isRunning) {
            ThreadUtil.sleep(sleepTime);
            count++;

    }

    @Test
    public void test_setCrawlerWaitMillis() {
        IntervalControlHelper helper = new IntervalControlHelper();

        // Test default wait time
        assertEquals(10000, helper.crawlerWaitMillis);

        // Test setting new wait time
        helper.setCrawlerWaitMillis(5000);
        assertEquals(5000, helper.crawlerWaitMillis);

        helper.setCrawlerWaitMillis(0);

    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the
   * future to finish, and when it completes, run the listeners. This implementation will wait on
   * the source future indefinitely, so if the source future never completes, the adapter will never
   * complete either.
   *

	// while counting the number of concurrent connections
	return int(globalHTTPListen.Subscribers()) + int(globalTrace.Subscribers())
}

func waitForLowIO(maxIO int, maxWait time.Duration, currentIO func() int) {
	// No need to wait run at full speed.
	if maxIO <= 0 {
		return
	}

	const waitTick = 100 * time.Millisecond

	tmpMaxWait := maxWait

	for currentIO() >= maxIO {
		if tmpMaxWait > 0 {
			if tmpMaxWait < waitTick {

          connectResult = launchTcpConnect()
          nextTcpConnectAtNanos = now + connectDelayNanos
          awaitTimeoutNanos = connectDelayNanos
        }

        // Wait for an in-flight connect to complete or fail.
        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

				fmt.Printf("Task in the queue: %#v\n", task)
			}
		default:
			// task queue is full, no more workers, we shall move on and heal later.
			return nil
		}
		// Don't wait for result
		return nil
	}

	// respCh must be set to wait for result.
	// We make it size 1, so a result can always be written
	// even if we aren't listening.
	task.respCh = make(chan healResult, 1)
	select {

```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

Regular Reads will block until data is available, but not wait for a full buffer. 
Writes will block until there is space available and writes bigger than the buffer will wait for reads to make space.

`TryRead` and `TryWrite` are still available for non-blocking reads and writes.

	)
	ErrInvalidBatchKeyRotationWorkersWait = newErrFn(
		"Invalid value for batch key rotation workers wait",
		"Please input a non-negative duration",
		"keyrotation_workers_wait should be > 0ms",
	)
	ErrInvalidBatchReplicationWorkersWait = newErrFn(
		"Invalid value for batch replication workers wait",
		"Please input a non-negative duration",
		"replication_workers_wait should be > 0ms",
	)

		return 0, err
	}

	// In case we're booting a device or emulator alongside all.bash, wait for
	// it to be ready. adb wait-for-device is not enough, we have to
	// wait for sys.boot_completed.
	if err := adb("wait-for-device", "exec-out", "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;"); err != nil {
		return 0, err
	}

	// Done once per make.bash.