Académique Documents
Professionnel Documents
Culture Documents
Nom :RACHID
Prenom :Aymane
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 :
try {
} catch (InterruptedException e) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
monThread.interrupt();
synchronized (resource1) {
try {
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (resource2) {
});
synchronized (resource2) {
try {
} catch (InterruptedException e) {
e.printStackTrace();
synchronized (resource1) {
});
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 {
semaphore.acquire(); // Opération P
try {
valeur++;
} finally {
semaphore.release(); // Opération V
this.ressource = ressource;
try {
ressource.utiliserRessource();
} catch (InterruptedException e) {
e.printStackTrace();
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 {
while (true) {
try {
} catch (InterruptedException e) {
e.printStackTrace();
});
daemonThread.setDaemon(true);
daemonThread.start();
try {
} 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.");
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
this.id = id;
this.leftFork = leftFork;
this.rightFork = rightFork;
rightFork.lock();
try {
} finally {
rightFork.unlock();
leftFork.unlock();
@Override
try {
while (true) {
penser();
manger();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
int nombrePhilosophes = 5;
new Thread(philosophes[i]).start();
6)
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
this.id = id;
this.verrou = verrou;
verrou.readLock().lock();
try {
System.out.println("Lecteur " + id + " lit.");
} finally {
verrou.readLock().unlock();
@Override
try {
while (true) {
lire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
this.id = id;
this.verrou = verrou;
verrou.writeLock().lock();
try {
System.out.println("Rédacteur " + id + " écrit.");
} finally {
verrou.writeLock().unlock();
@Override
try {
while (true) {
ecrire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
int nombreLecteurs = 5;
int nombreRedacteurs = 2;
7)