final int threadId = i;
                    executor.submit(() -> {
                        try {
                            startLatch.await(); // Wait for all threads to be ready
                            for (int j = 0; j < searchersPerThread; j++) {
                                processor.register(new TestSearcher(10 + threadId * 10 + j));

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    for (int i = 0; i < operationsPerThread; i++) {
                        String sid = "thread-" + threadId + "-key-" + i;
                        byte[] key = keyManager.generateRandomKey(16);

                        // Store key

        // Trip circuit
        circuitBreaker.trip();
        Thread.sleep(100);

        long afterTripTime = circuitBreaker.getTimeSinceLastStateChange();
        assertTrue(afterTripTime >= 100, "Time should have advanced");
        assertTrue(afterTripTime < 200, "Time should be reasonable");

        // Reset circuit
        circuitBreaker.reset();
        Thread.sleep(50);

        // Test thread safety
        final int threadCount = 10;
        final int docsPerThread = 10;
        final List<Thread> threads = new ArrayList<>();
        final AtomicInteger successCount = new AtomicInteger(0);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            Thread thread = new Thread(() -> {

                Arrays.fill(dataArrays[i], (byte) i);

                threads[i] = new Thread(() -> {
                    digest.sign(dataArrays[index], 0, dataArrays[index].length, request, response);
                });
            }

            for (Thread t : threads) {
                t.start();
            }
            for (Thread t : threads) {
                t.join();
            }

            return true;
        });
    }

    private void addMdcContext(Map<String, Object> context) {
        // Add MDC context efficiently
        context.put("thread", Thread.currentThread().getName());
        context.put("threadId", Thread.currentThread().getId());

        String sessionId = MDC.get("sessionId");
        if (sessionId != null) {
            context.put("sessionId", sessionId);
        }

                            }
                        }
                    }
                    long threadEnd = System.nanoTime();
                    totalTime.addAndGet(threadEnd - threadStart);

                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    endLatch.countDown();
                }
            });

     * shouldn't)
     *
     * Our solution is for threads to CAS seenExceptionsField from null to a Set populated with _the
     * initial exception_, no matter which thread does the work. This ensures that
     * seenExceptionsField always contains not just the current thread's exception but also the
     * initial thread's.
     */
    Set<Throwable> seenExceptionsLocal = seenExceptionsField;

        Thread thread2 = new Thread(() -> {
            Throwable result = exception.fillInStackTrace();
            assertNull(result);
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            fail("Thread interrupted");
        }
    }

    @Test

          } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
          }
          runCalled.getAndIncrement();
        },
        directExecutor());
    Runnable execute = list::execute;
    Thread thread1 = new Thread(execute);
    Thread thread2 = new Thread(execute);
    thread1.start();
    thread2.start();
    assertEquals(0, runCalled.get());