}
        
        return CompletableFuture.supplyAsync(() -> {
            try {
                // Wait before retry (except first attempt)
                if (attempt > 0) {
                    Thread.sleep(retryDelay * attempt);
                }
                
                // Create reconnect context
                DurableHandleReconnect reconnectCtx = 
                    new DurableHandleReconnect(info.fileId);

                            session.release();
                        } else {
                            session.acquire();
                            // Hold for a bit
                            Thread.sleep(1);
                            session.release();
                        }
                    }
                } catch (Exception e) {

func (m *metacacheManager) initManager() {
	// Add a transient bucket.
	// Start saver when object layer is ready.
	go func() {
		objAPI := newObjectLayerFn()
		for objAPI == nil {
			time.Sleep(time.Second)
			objAPI = newObjectLayerFn()
		}

		t := time.NewTicker(time.Minute)
		defer t.Stop()

		var exit bool
		for !exit {
			select {
			case <-t.C:
			case <-GlobalContext.Done():

                dataCrawlingThreadStatusList.set(startedCrawlerNum, Constants.RUNNING);
                startedCrawlerNum++;
                activeCrawlerNum++;
                ThreadUtil.sleep(crawlingExecutionInterval);
                continue;
            }

            // check status
            for (int i = 0; i < startedCrawlerNum; i++) {

        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            // adds two nanoseconds to the ticker
            ticker.advance(1L);
            Thread.sleep(10);
            ticker.advance(1L);
            return null;
          }
        });

    assertEquals(numberOfThreads * 2, ticker.read());
  }

  @GwtIncompatible // concurrency

        manager.requestDurableHandle("/test/file.txt", HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        HandleInfo info = manager.getHandleForReconnect("/test/file.txt");
        assertNull(info);

            while (!isInterrupted() && !stopIfLeisure()) {
                for (final TimeoutTask task : getExpiredTask()) {
                    processTask(executorService, task);
                }
                Thread.sleep(1000L);
            }
        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Interrupted.", e);
            }
        } finally {

        IOException error = new IOException("Connection failed");
        failover.handleFailure(failedChannel, error);

        // Wait a bit for recovery attempt
        Thread.sleep(100);

        verify(mockChannelManager).createTransport(failedChannel.getLocalInterface(), failedChannel.getRemoteInterface());
    }

    @Test
    void testMultipleFailuresExceedRetryLimit() {

        assertFalse(helper.isCrawlerRunning());

        // Start a thread to set crawler running after a delay
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(100);
                helper.setCrawlerRunning(true);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        thread.start();

        InputStreamThread thread = new InputStreamThread(is, StandardCharsets.UTF_8, 10, null);
        thread.start();

        Thread.sleep(50);

        String output1 = thread.getOutput();
        boolean contains1 = thread.contains("concurrent1");

        thread.join(1000);

        String output2 = thread.getOutput();