for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await(); // Wait for all threads to be ready

                    for (int i = 0; i < opsPerThread; i++) {
                        String share = "share" + (threadId % 3); // Use 3 different shares

            ready.countDown()
            try {
              proceed.await(5, TimeUnit.SECONDS)
            } catch (e: InterruptedException) {
              throw RuntimeException(e)
            }
            chain.proceed(chain.request())
          },
        ).build()
    val t1 = makeSynchronousCall(client.newCall(newRequest("http://a/3")))
    ready.await(5, TimeUnit.SECONDS)
    executor.finishJob("http://a/2")

        for (int i = 0; i < threadCount; i++) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        startLatch.await();
                        for (int j = 0; j < operationsPerThread; j++) {
                            crawlerContext.incrementAndGetAccessCount();
                        }

        // Start timing
        long overallStart = System.nanoTime();

        for (int t = 0; t < threadCount; t++) {
            executor.submit(() -> {
                try {
                    startLatch.await();

                    long threadStart = System.nanoTime();
                    for (int i = 0; i < operationsPerThread; i++) {
                        try {

            });

            longRunningThread.start();
            startLatch.await();

            // Check active requests
            assertEquals(1, cbWithTracking.getActiveRequests(), "Should have 1 active request");

            // Complete the operation
            holdLatch.countDown();
            completeLatch.await();
            longRunningThread.join();

                        startLatch.await();
                        response.received();
                        endLatch.countDown();
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }).start();
            }

            startLatch.countDown();
            assertTrue(endLatch.await(1, TimeUnit.SECONDS));

            final int threadId = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        startLatch.await();
                        for (int j = 0; j < rulesPerThread; j++) {
                            TestRule rule = new TestRule("rule_" + threadId + "_" + j, true);
                            threadSafeManager.addRule(rule);

            AtomicInteger completedOps = new AtomicInteger(0);

            for (int t = 0; t < threadCount; t++) {
                executor.submit(() -> {
                    try {
                        startLatch.await(); // All threads start simultaneously
                        for (int i = 0; i < operationsPerThread; i++) {
                            byte[] localData = new byte[128];

        }

        // Run concurrent updates
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    startLatch.await();
                    Method updateMethod = findMethod(transport.getClass(), "updatePreauthHash", byte[].class);
                    updateMethod.setAccessible(true);
                    updateMethod.invoke(transport, testData);

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()
    assertThat(exceptionRef.get()).isNotNull()
  }

  @Test
  fun timeoutProcessing() {
    server.enqueue(
      MockResponse
        .Builder()