Un contenedor está en ejecución mientras el **proceso principal** (comando o programa) esté en ejecución.

Un contenedor normalmente tiene un **proceso único**, pero también es posible iniciar subprocesos desde el proceso principal, y de esa manera tendrás **múltiples procesos** en el mismo contenedor.

Pero no es posible tener un contenedor en ejecución sin **al menos un proceso en ejecución**. Si el proceso principal se detiene, el contenedor se detiene.

        }

        ModelObjectProcessor processor = ProcessorHolder.CACHED_PROCESSOR.get();
        if (processor == null) {
            processor = loadProcessor();
            ProcessorHolder.CACHED_PROCESSOR.compareAndSet(null, processor);
            processor = ProcessorHolder.CACHED_PROCESSOR.get();
        }
        return processor.process(object);
    }

    /**

import jakarta.annotation.PostConstruct;

/**
 * Response processor implementation for the Fess search engine.
 * This processor extends DefaultResponseProcessor to provide additional
 * processing capabilities through the ingest framework, allowing for
 * custom data transformation and enrichment during the crawling process.
 *
 * <p>It supports pluggable ingesters that can modify the result data

Guillaume Nodet <******@****.***> 1725988727 +0200

Tienden a requerir configuraciones más complejas, un gestor de cola de mensajes/trabajos, como RabbitMQ o Redis, pero te permiten ejecutar tareas en segundo plano en múltiples procesos, y especialmente, en múltiples servidores.

     * @param pageSize The number of hits per scroll page
     * @param processor The processor to convert each hit into result items
     * @return A list of processed results
     */
    public static <T> List<T> scrollSearch(final Client client, final SuggestSettings settings, final String index,
            final QueryBuilder query, final int pageSize, final HitProcessor<T> processor) {

        final List<T> results = new ArrayList<>();

        public org.dbflute.optional.OptionalThingIfPresentAfter ifExecutingNow(
                final java.util.function.Consumer<org.lastaflute.job.subsidiary.SnapshotExecState> oneArgLambda) {
            return processor -> processor.process();
        }

        @Override
        public java.util.Set<org.lastaflute.job.key.LaJobKey> getTriggeredJobKeySet() {
            return Collections.emptySet();
        }

        @Override

Esta es la idea básica. Pero probablemente querrás encargarte de algunas cosas adicionales, como:

* Seguridad - HTTPS
* Ejecución en el arranque
* Reinicios
* Replicación (el número de procesos ejecutándose)
* Memoria
* Pasos previos antes de comenzar

   * This method will be called for each chunk of bytes in an input stream. The implementation
   * should process the bytes from {@code buf[off]} through {@code buf[off + len - 1]} (inclusive).
   *
   * @param buf the byte array containing the data to process
   * @param off the initial offset into the array
   * @param len the length of data to be processed
   * @return true to continue processing, false to stop
   */

    protected HashCode makeHash() {
      // End with a byte encoding the positive integer b mod 256.
      finalM ^= b << 56;
      processM(finalM);

      // Finalization
      v2 ^= 0xFFL;
      sipRound(d);
      return HashCode.fromLong(v0 ^ v1 ^ v2 ^ v3);
    }

    private void processM(long m) {
      v3 ^= m;
      sipRound(c);
      v0 ^= m;
    }

    private void sipRound(int iterations) {