if (!channelExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                channelExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // Private helper methods

    private int getMaxChannelsFromConfig(Configuration config) {
        // In a real implementation, this would read from configuration

        if (t != null && Thread.currentThread() != t) {
            this.thread = null;
            try {
                log.debug("Interrupting transport thread");
                t.interrupt();
                log.debug("Joining transport thread");
                t.join(timeout);
                log.debug("Joined transport thread");
            } catch (final InterruptedException e) {

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

            startLatch.countDown(); // Start all threads

    this.futures = checkNotNull(futures);
    this.allMustSucceed = allMustSucceed;
    this.collectsValues = collectsValues;
  }

  @Override
  @SuppressWarnings("Interruption") // We are propagating an interrupt from a caller.
  protected final void afterDone() {
    super.afterDone();

    @RetainedLocalRef ImmutableCollection<? extends Future<?>> localFutures = futures;

                healthCheckExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            healthCheckExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Close all connections without synchronization - concurrent collections are thread-safe
        connections.forEach(conn -> {
            try {
                conn.disconnect(true, true);

                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        });
    }
    

## Running on Startup { #running-on-startup }

In most cases, when you create a web API, you want it to be **always running**, uninterrupted, so that your clients can always access it. This is of course, unless you have a specific reason why you want it to run only in certain situations, but most of the time you want it constantly running and **available**.

        // Wait briefly for witness notification before retrying
        try {
            Thread.sleep(2000);  // 2 second grace period
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    // Proceed with normal error handling/retry
    super.handleConnectionLoss(error);
}
```

## 6. Configuration

### 6.1 Configuration Properties
```java

// serverMain handler called for 'minio server' command.
func serverMain(ctx *cli.Context) {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))

	var warnings []string

	signal.Notify(globalOSSignalCh, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)

	go handleSignals()

	setDefaultProfilerRates()

	// Initialize globalConsoleSys system
	bootstrapTrace("newConsoleLogger", func() {

      } catch (Throwable t) {
        ListenableFuture<V> result = setException(t) ? futureValue : fullyFailedFuture(t);
        if (t instanceof InterruptedException) {
          Thread.currentThread().interrupt();
        }
        return result;
      }
    }

    public @Nullable V compute(
        K key, BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> function) {