1)Une interruption se réfère généralement à l'action de suspendre

temporairement une activité en cours, un processus ou un état pour donner la

priorité à une autre activité ou pour permettre le traitement d'une information
particulière
Code :

class MonThread extends Thread {

public void run() {

try {

System.out.println("Le thread démarre...");

Thread.sleep(5000); // Le thread dort pendant 5 secondes

System.out.println("Le thread a terminé son travail.");

} catch (InterruptedException e) {

System.out.println("Le thread a été interrompu !");

public class ExempleInterruption {

public static void main(String[] args) {

MonThread monThread = new MonThread();

monThread.start(); // Démarrer le thread

// Attendre un moment

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

// Interruption du thread après 2 secondes

monThread.interrupt();
 }

2) Un "deadlock" (ou impasse en français) se produit dans la programmation

multithread lorsqu'un ensemble de threads est bloqué parce que chaque
thread attend que l'autre libère une ressource. En d'autres termes, chaque
thread est bloqué indéfiniment, attendant que quelque chose se produise, mais
cela ne se produit jamais
Code :
public class DeadlockExample {

public static void main(String[] args) {

// Deux ressources fictives

Object resource1 = new Object();

Object resource2 = new Object();

// Premier thread qui verrouille resource1 puis resource2

Thread thread1 = new Thread(() -> {

synchronized (resource1) {

System.out.println("Thread 1: Verrouille resource1");

try {

Thread.sleep(100); // Pour donner une chance à l'autre thread

} catch (InterruptedException e) {

e.printStackTrace();

synchronized (resource2) {

System.out.println("Thread 1: Verrouille resource2");

});

// Deuxième thread qui verrouille resource2 puis resource1

 Thread thread2 = new Thread(() -> {

synchronized (resource2) {

System.out.println("Thread 2: Verrouille resource2");

try {

Thread.sleep(100); // Pour donner une chance à l'autre thread

} catch (InterruptedException e) {

e.printStackTrace();

synchronized (resource1) {

System.out.println("Thread 2: Verrouille resource1");

});

// Démarrer les deux threads

thread1.start();

thread2.start();

3) Un sémaphore est un mécanisme de synchronisation qui permet à plusieurs threads

d'accéder simultanément à une ressource limitée. Il maintient un compteur interne qui est
utilisé pour contrôler l'accès aux ressources partagées. Les threads peuvent effectuer des
opérations P (proberen, signifiant "essayer" en néerlandais) et V (verhogen, signifiant
"augmenter" en néerlandais) sur le sémaphore.
Code :
import java.util.concurrent.Semaphore;

class RessourcePartagee {

// Un exemple de ressource partagée

private int valeur = 0;

 // Un sémaphore avec un seul "permis"

private Semaphore semaphore = new Semaphore(1);

public void utiliserRessource() throws InterruptedException {

semaphore.acquire(); // Opération P

try {

// Section critique : accès à la ressource partagée

valeur++;

System.out.println("Thread " + Thread.currentThread().getId() + " utilise la ressource. Valeur : "

+ valeur);

} finally {

semaphore.release(); // Opération V

class MonThread extends Thread {

private RessourcePartagee ressource;

public MonThread(RessourcePartagee ressource) {

this.ressource = ressource;

public void run() {

try {

// Utilisation de la ressource partagée

ressource.utiliserRessource();

} catch (InterruptedException e) {

e.printStackTrace();
 }

public class SemaphoreExemple {

public static void main(String[] args) {

RessourcePartagee ressourcePartagee = new RessourcePartagee();

// Création de plusieurs threads qui utilisent la ressource partagée

for (int i = 0; i < 5; i++) {

MonThread thread = new MonThread(ressourcePartagee);

thread.start();

4) En Java, un daemon thread (thread démon) est un thread qui s'exécute en arrière-plan
et ne bloque pas la terminaison du programme. Si tous les threads non démons se
terminent, le programme se termine, même si des threads démons sont toujours en cours
d'exécution. Les threads démons sont généralement utilisés pour effectuer des tâches de
fond, comme la collecte de statistiques ou la maintenance, et sont arrêtés lorsque tous les
threads non démons ont terminé.
Code :

public class DaemonThreadExample {

public static void main(String[] args) {

// Création d'un thread démon

Thread daemonThread = new Thread(() -> {

while (true) {

System.out.println("Thread démon en cours d'exécution...");

try {

Thread.sleep(1000); // Pause d'une seconde

} catch (InterruptedException e) {

e.printStackTrace();
 }

});

// Définir le thread comme un thread démon

daemonThread.setDaemon(true);

// Démarrer le thread démon

daemonThread.start();

// Le thread principal effectue quelques tâches

for (int i = 0; i < 5; i++) {

System.out.println("Thread principal en cours d'exécution...");

try {

Thread.sleep(2000); // Pause de deux secondes

} catch (InterruptedException e) {

e.printStackTrace();

System.out.println("Fin du programme. Le thread principal se termine, et le thread démon

s'arrêtera également.");

5) Le problème des philosophes dînants est un classique en informatique concrète et illustre

les défis de la synchronisation dans les systèmes informatiques multithreadés. Le problème
décrit un groupe de philosophes assis autour d'une table, chacun ayant une assiette de
spaghettis devant lui. Un philosophe alterne entre deux états: penser et manger. Cependant,
pour manger, un philosophe a besoin de deux fourchettes, une à sa gauche et une à sa
droite.
Code :

Voici une implémentation simple du problème des philosophes dînants en Java :

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

class Philosophe implements Runnable {

private int id;

private Lock leftFork;

private Lock rightFork;

public Philosophe(int id, Lock leftFork, Lock rightFork) {

this.id = id;

this.leftFork = leftFork;

this.rightFork = rightFork;

private void penser() throws InterruptedException {

System.out.println("Philosophe " + id + " pense.");

Thread.sleep((long) (Math.random() * 1000));

private void manger() throws InterruptedException {

leftFork.lock();

rightFork.lock();

try {

System.out.println("Philosophe " + id + " mange.");

Thread.sleep((long) (Math.random() * 1000));

} finally {

rightFork.unlock();

leftFork.unlock();

}
 @Override

public void run() {

try {

while (true) {

penser();

manger();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

public class DinerPhilosophes {

public static void main(String[] args) {

int nombrePhilosophes = 5;

Lock[] fourchettes = new Lock[nombrePhilosophes];

for (int i = 0; i < nombrePhilosophes; i++) {

fourchettes[i] = new ReentrantLock();

Philosophe[] philosophes = new Philosophe[nombrePhilosophes];

for (int i = 0; i < nombrePhilosophes; i++) {

philosophes[i] = new Philosophe(i, fourchettes[i], fourchettes[(i + 1) % nombrePhilosophes]);

new Thread(philosophes[i]).start();

6)
Le problème des lecteurs-rédacteurs est un autre problème classique de
synchronisation dans les systèmes multithreadés. Il implique un ensemble de threads
lecteurs et un ensemble de threads rédacteurs qui partagent une ressource (par exemple,
une base de données). Les lecteurs peuvent accéder à la ressource simultanément, mais les
rédacteurs ont un accès exclusif.
Code :

import java.util.concurrent.locks.ReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

class Lecteur implements Runnable {

private int id;

private ReadWriteLock verrou;

public Lecteur(int id, ReadWriteLock verrou) {

this.id = id;

this.verrou = verrou;

private void lire() throws InterruptedException {

verrou.readLock().lock();

try {

System.out.println("Lecteur " + id + " lit.");

Thread.sleep((long) (Math.random() * 1000));

} finally {

verrou.readLock().unlock();

@Override

public void run() {

try {

while (true) {
 lire();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

class Redacteur implements Runnable {

private int id;

private ReadWriteLock verrou;

public Redacteur(int id, ReadWriteLock verrou) {

this.id = id;

this.verrou = verrou;

private void ecrire() throws InterruptedException {

verrou.writeLock().lock();

try {

System.out.println("Rédacteur " + id + " écrit.");

Thread.sleep((long) (Math.random() * 1000));

} finally {

verrou.writeLock().unlock();

@Override

public void run() {

try {

while (true) {
 ecrire();

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

public class LecteursRedacteurs {

public static void main(String[] args) {

int nombreLecteurs = 5;

int nombreRedacteurs = 2;

ReadWriteLock verrou = new ReentrantReadWriteLock();

for (int i = 0; i < nombreLecteurs; i++) {

new Thread(new Lecteur(i, verrou)).start();

for (int i = 0; i < nombreRedacteurs; i++) {

new Thread(new Redacteur(i, verrou)).start();

7)