/** Runnable is not running and not queued for execution */
    IDLE,
    /** Runnable is not running, but is being queued for execution */
    QUEUING,
    /** runnable has been submitted but has not yet begun execution */
    QUEUED,
    RUNNING,
  }

  /** Underlying executor that all submitted Runnable objects are run on. */
  private final Executor executor;

  @GuardedBy("queue")

    ready.await()
    assertThat(dispatcher.runningCallsCount()).isEqualTo(2)
    assertThat(dispatcher.queuedCallsCount()).isEqualTo(0)
    assertThat(dispatcher.runningCalls())
      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Cancel some calls. That doesn't impact running or queued.
    a2.cancel()
    a3.cancel()

| `minio_cluster_replication_last_minute_queued_count`       | Total number of objects queued for replication in the last full minute                                   |
| `minio_cluster_replication_last_minute_queued_bytes`       | Total number of bytes queued for replication in the last full minute                                     |

    /**
     * Used to update and read the latestTaskQueue field. Set to null once the runnable has been run
     * or queued.
     */
    @CheckForNull ExecutionSequencer sequencer;

    /**
     * Executor the task was set to run on. Set to null when the task has been queued, run, or
     * cancelled.
     */
    @CheckForNull Executor delegate;

    /**

			}
		case "ReplicaCount":
			z.ReplicaCount, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ReplicaCount")
				return
			}
		case "Queued":
			err = z.Queued.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Queued")
				return
			}
		case "Proxied":
			err = z.Proxied.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Proxied")
				return
			}

### Replication of object version and metadata

	h.client = &http.Client{Transport: h.config.Transport}

	if h.config.QueueDir != "" {

		queueStore := store.NewQueueStore[interface{}](
			filepath.Join(h.config.QueueDir, h.Name()),
			uint64(h.config.QueueSize),
			httpLoggerExtension,
		)

		if err := queueStore.Open(); err != nil {
			return h, fmt.Errorf("unable to initialize the queue store of %s webhook: %w", h.Name(), err)
		}

		h.store = queueStore

              protected void finalize() {
                finalizerRan.countDown();
              }
            });

    await(finalizerRan);
    awaitClear(ref);

    // Hope to catch some stragglers queued up behind our finalizable object
    System.runFinalization();
  }

  private static RuntimeException formatRuntimeException(String format, Object... args) {

              protected void finalize() {
                finalizerRan.countDown();
              }
            });

    await(finalizerRan);
    awaitClear(ref);

    // Hope to catch some stragglers queued up behind our finalizable object
    System.runFinalization();
  }

  private static RuntimeException formatRuntimeException(String format, Object... args) {

}

func (r *ReplicationStats) getSRMetricsForNode() SRMetricsSummary {
	if r == nil {
		return SRMetricsSummary{}
	}

	m := SRMetricsSummary{
		Uptime:        UTCNow().Unix() - globalBootTime.Unix(),
		Queued:        r.qCache.getSiteStats(),
		ActiveWorkers: r.ActiveWorkers(),
		Metrics:       r.srStats.get(),
		Proxied:       r.pCache.getSiteStats(),
		ReplicaSize:   atomic.LoadInt64(&r.srStats.ReplicaSize),