Qu'est-ce qu'un thread?

Un thread est une unité d'exécution légère qui permet à un programme de

s'exécuter de manière concurrente. Un programme peut avoir plusieurs threads
qui s'exécutent en parallèle, ce qui permet d'effectuer plusieurs tâches
simultanément. Chaque thread a son propre flux d'exécution et peut exécuter
des instructions indépendamment des autres threads.

Quelle est la différence entre un processus et un thread?

Un processus est un programme en cours d'exécution, avec son propre espace

mémoire et ses ressources système. Il peut contenir plusieurs threads qui
s'exécutent de manière concurrente.

Un thread, en revanche, est une unité d'exécution à l'intérieur d'un processus. Il

partage le même espace mémoire et les mêmes ressources que les autres
threads du même processus. Les threads permettent une exécution parallèle à
l'intérieur d'un processus, ce qui permet d'effectuer plusieurs tâches
simultanément.

En résumé, un processus est un conteneur pour les threads, tandis que les
threads sont les unités d'exécution réelles à l'intérieur d'un processus.

Comment créer et exécuter un thread en Java?

En Java, il existe deux façons courantes de créer et d'exécuter un thread :

1. En étendant la classe Thread :

- Créez une classe qui étend la classe Thread.
- Implémentez la méthode `run()` dans cette classe, qui contient le code que le
thread exécutera.
- Créez une instance de la classe étendue et appelez la méthode `start()` pour
démarrer l'exécution du thread.

Voici un exemple :
```java
public class MonThread extends Thread {
public void run() {
// Code à exécuter dans le thread
}
}

public class Main {

public static void main(String[] args) {
MonThread monThread = new MonThread();
monThread.start();
}
}
```

2. En implémentant l'interface Runnable :

- Créez une classe qui implémente l'interface Runnable.
- Implémentez la méthode `run()` dans cette classe, qui contient le code que le
thread exécutera.
- Créez une instance de la classe implémentant Runnable et passez-la comme
argument à un objet Thread.
- Appelez la méthode `start()` sur l'objet Thread pour démarrer l'exécution du
thread.

Voici un exemple :

```java
public class MonThreadRunnable implements Runnable {
public void run() {
// Code à exécuter dans le thread
}
}

public class Main {

public static void main(String[] args) {
MonThreadRunnable monThreadRunnable = new MonThreadRunnable();
Thread thread = new Thread(monThreadRunnable);
 thread.start();
}
}
```

Dans les deux cas, le code à exécuter dans le thread est placé dans la méthode
`run()`. Lorsque la méthode `start()` est appelée, le thread est créé et commence
à exécuter le code de la méthode `run()` de manière concurrente.

- L'exécution d'un thread peut être contrôlée à l'aide de méthodes telles que
start(), sleep(), yield(), join(), etc.
- Les threads peuvent être synchronisés pour éviter les problèmes de
concurrence en utilisant des mots-clés tels que synchronized, wait() et notify().
- Les threads peuvent avoir des priorités d'exécution pour influencer l'ordre dans
lequel ils sont exécutés par l'ordonnanceur.
- Les groupes de threads permettent de regrouper des threads et de les
manipuler de manière cohérente.
- Les threads sont utiles dans les systèmes répartis pour gérer la concurrence, la
communication et la synchronisation entre les différentes parties du système.