///

---

Dans ce scénario de burgers parallèles, vous êtes un ordinateur / programme 🤖 avec deux processeurs (vous et votre crush 😍) attendant 🕙 à deux et dédiant votre attention ⏯ à « attendre devant le comptoir » 🕙 pour une longue durée.

Le fast-food a 8 processeurs (serveurs/cuisiniers) 👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳. Alors que le fast-food de burgers concurrents en avait 2 (un serveur et un cuisinier).

### Multiples processus - Un exemple { #multiple-processes-an-example }

Dans cet exemple, il y a un **processus gestionnaire** qui démarre et contrôle deux **processus workers**.

Ce processus gestionnaire serait probablement celui qui écoute sur le **port** de l'IP. Et il transmettrait toute la communication aux processus workers.

Un conteneur fonctionne tant que le **processus principal** (commande ou programme) est en cours d'exécution.

Un conteneur a normalement un **seul processus**, mais il est aussi possible de démarrer des sous-processus à partir du processus principal, et ainsi vous aurez **plusieurs processus** dans le même conteneur.

/**
 * Provides tools for processing Maven dependency injection annotations at compile time.
 * <p>
 * This package contains annotation processors that generate metadata files used by
 * the Maven dependency injection system. The main component is the {@link org.apache.maven.di.tool.DiIndexProcessor},
 * which processes classes annotated with {@link org.apache.maven.api.di.Named} and creates an index file

            final Set<String> processedUrls = new HashSet<>();
            requestQueue.offer(new CrawlRequest(url, 0));
            while (!requestQueue.isEmpty() && (maxAccessCount < 0 || counter < maxAccessCount)) {
                final CrawlRequest crawlRequest = requestQueue.poll();
                if ((maxDepth != -1 && crawlRequest.getDepth() > maxDepth) || processedUrls.contains(crawlRequest.getUrl())) {

* l’en-tête d’autorisation
* l’en-tête `Authorization`
* l’en-tête transféré

* le système d’injection de dépendances
* la dépendance
* l’élément dépendable
* le dépendant

* lié aux E/S
* lié au processeur
* concurrence
* parallélisme
* multi-traitement

* la variable d’env
* la variable d’environnement
* le `PATH`
* la variable `PATH`

* l’authentification

```

</div>

////

La seule option nouvelle ici est `--workers` qui indique à Uvicorn de démarrer 4 processus workers.

Vous pouvez aussi voir qu'il affiche le **PID** de chaque processus, `27365` pour le processus parent (c'est le **gestionnaire de processus**) et un pour chaque processus worker : `27368`, `27369`, `27370` et `27367`.

## Concepts de déploiement { #deployment-concepts }

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

func (cs *callbacks) Row() *processor {
	return cs.processors["row"]
}

* Others...

## Replication - Processes and Memory { #replication-processes-and-memory }

With a FastAPI application, using a server program like the `fastapi` command that runs Uvicorn, running it once in **one process** can serve multiple clients concurrently.

But in many cases, you will want to run several worker processes at the same time.

### Multiple Processes - Workers { #multiple-processes-workers }

- Worker processes. Long-running daemon processes that the Gradle daemon starts to run specific kinds of work, such as compilation or test execution.

The diagram below shows the relationships between the different processes:

```mermaid
    graph LR
        
        gradle["Gradle CLI client"]