}

        public void decrementConnections() {
            activeConnections.decrementAndGet();
        }

        public boolean isHealthy() {
            return isHealthy;
        }

        public void setHealthy(boolean healthy) {
            this.isHealthy = healthy;
            this.lastHealthCheck = System.currentTimeMillis();
        }

        public long getLastHealthCheck() {

  /**
   * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy}. The manager
   * will become healthy after all the component services have reached the {@linkplain State#RUNNING
   * running} state.
   *
   * @throws IllegalStateException if the service manager reaches a state from which it cannot
   *     become {@linkplain #isHealthy() healthy}.
   */
  public void awaitHealthy() {
    state.awaitHealthy();

        return System.currentTimeMillis() - lastActivityTime;
    }

    /**
     * Check if channel is in healthy state
     *
     * @return true if healthy
     */
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }

    /**
     * Get channel binding hash
     *
     * @return binding hash bytes
     */

    }

    val http2Connection = this.http2Connection
    if (http2Connection != null) {
      return http2Connection.isHealthy(nowNs)
    }

    val idleDurationNs = withLock { nowNs - idleAtNs }
    if (idleDurationNs >= IDLE_CONNECTION_HEALTHY_NS && doExtensiveChecks) {
      return javaNetSocket.isHealthy(socket.source)
    }

    return true
  }

  /** Refuse incoming streams. */

    manager.addListener(listener, directExecutor());
    assertState(manager, Service.State.NEW, a, b);
    assertFalse(manager.isHealthy());
    manager.startAsync().awaitHealthy();
    assertState(manager, Service.State.RUNNING, a, b);
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());

    manager.addListener(listener, directExecutor());
    assertState(manager, Service.State.NEW, a, b);
    assertFalse(manager.isHealthy());
    manager.startAsync().awaitHealthy();
    assertState(manager, Service.State.RUNNING, a, b);
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());

     *
     * @return collection of healthy channels
     */
    public Collection<ChannelInfo> getHealthyChannels() {
        return channels.values()
                .stream()
                .filter(ChannelInfo::isHealthy)
                .collect(ArrayList::new, (list, item) -> list.add(item), (list1, list2) -> list1.addAll(list2));
    }

    /**
     * Select a channel for the given message
     *

  private fun waitForConnectionShutdown(connection: RealConnection?) {
    if (connection!!.isHealthy(false)) {
      Thread.sleep(100L)
    }
    if (connection.isHealthy(false)) {
      Thread.sleep(2000L)
    }
    if (connection.isHealthy(false)) {
      throw TimeoutException("connection didn't shutdown within timeout")
    }
  }

  /**

      withLock {
        if (isShutdown) {
          throw ConnectionShutdownException()
        }
        okHttpSettings.merge(settings)
      }
      writer.settings(settings)
    }
  }

  fun isHealthy(nowNs: Long): Boolean {
    withLock {
      if (isShutdown) return false

      // A degraded pong is overdue.
      if (degradedPongsReceived < degradedPingsSent && nowNs >= degradedPongDeadlineNs) return false

        this.lastActivityTime = System.currentTimeMillis();
    }
    
    public long getIdleTime() {
        return System.currentTimeMillis() - lastActivityTime;
    }
    
    public boolean isHealthy() {
        return state == ChannelState.ACTIVE || state == ChannelState.ESTABLISHED;
    }
    
    public double getErrorRate() {
        long total = requestsSent.get();
        if (total == 0) return 0.0;