Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

classe java.lang.Thread

Un thread est la plus petite partie légère d'un processus pouvant s'exécuter simultanément avec les autres parties (autres threads) du même processus. Les threads sont indépendants car ils ont tous un chemin d’exécution distinct. C’est pourquoi si une exception se produit dans un thread, cela n’affecte pas l’exécution des autres threads. Tous les threads d'un processus partagent la mémoire commune. Le processus d'exécution simultanée de plusieurs threads est appelé multithreading.

Java fournit la classe java.lang.Thread pour réaliser la programmation de thread. La classe Thread fournit des constructeurs et des méthodes pour créer et effectuer des opérations sur un thread. La classe Thread hérite de la classe Object et implémente l'interface Runnable.

Constructeurs de la classe Thread

ConstructeurDescription
Thread()Ce constructeur alloue un nouvel objet Thread.
Thread(Runnable target)Ce constructeur alloue un nouvel objet Thread.
Thread(Runnable target, String name): Ce constructeur alloue un nouvel objet Thread.
Thread(String name): Ce constructeur alloue un nouvel objet Thread.
Thread(ThreadGroup group, Runnable target)Ce constructeur alloue un nouvel objet Thread de manière à ce qu'il appartient au groupe de threads désigné par group.
Thread(ThreadGroup group, Runnable target, String name)Alloue un nouvel objet Thread de manière à ce qu'il ait pour cible l'objet cible, qu'il porte le nom spécifié et qu'il appartient au groupe de threads désigné par group.
Thread(ThreadGroup group, Runnable target, String name, long stackSize)Cela alloue un nouvel objet Thread de manière à ce qu'il ait pour cible l'objet target, qu'il porte le nom name spécifié, qu'il appartient au groupe de threads désigné par group et qu'il possède la taille de pile spécifiée (stackSize).
Thread(ThreadGroup group, String name)Ce constructeur alloue un nouvel objet Thread de manière à ce qu'il appartient au groupe de threads désigné par group.

Méthodes de la classe Thread

Vous trouverez ci-dessous la liste des méthodes importantes disponibles dans la classe Thread.

MéthodeDescription
public void start()Démarre le thread dans un chemin d’exécution séparé, puis appelle la méthode run() sur cet objet Thread.
public void run()Si cet objet Thread a été instancié à l'aide d'une cible Runnable distinct, la méthode run () est appelée sur cet objet Runnable.
public final void setName(String name)Change le nom de l'objet Thread. elle existe également une méthode getName() pour récupérer le nom.
public final void setPriority(int priority)Définit la priorité de cet objet Thread. Les valeurs possibles sont comprises entre 1 et 10.
public final void setDaemon(boolean on)Un paramètre de true indique que ce thread est un thread de démon.
public final void join(long millisec)Le thread en cours appelle cette méthode sur un autre thread, ce qui provoque le blocage du thread en cours jusqu'à ce que l’autre thread se termine ou que le nombre millisec spécifié soit dépassé.
public void interrupt()Interrompt ce thread, le forçant à continuer son exécution s'il était bloqué pour une raison quelconque.
public final boolean isAlive()Renvoie true si le thread est actif, c'est-à-dire à tout moment après son démarrage mais avant son achèvement.

Les méthodes précédentes sont appelées sur un objet Thread particulier. Les méthodes suivantes de la classe Thread sont statiques. L'appel de l'une des méthodes statiques effectue l'opération sur le thread en cours d'exécution.

MéthodeDescription
public static void yield()Fait en sorte que le thread en cours d'exécution cède le passage à d'autres threads de la même priorité en attente de planification.
public static void sleep(long millisec)Force le thread en cours d'exécution à se bloquer pendant au moins le nombre millisec spécifié.
public static boolean holdsLock(Object x)Renvoie true si le thread en cours détient le verrou sur l'objet donné.
public static Thread currentThread()Renvoie une référence au thread en cours d'exécution, à savoir le thread qui appelle cette méthode.
public static void dumpStack()Affiche la trace de pile pour le thread en cours d'exécution, ce qui est utile lors du débogage d'une application multithread.
Exemple 1 - yield()
                                        class Multithreading implements Runnable {
                                            public void run() {
                                                try {
                                                    for (int i = 0; i < 5; i++)
                                                        System.out.println(Thread.currentThread().getName() + " a le controle");
                                        
                                                } catch (Exception e) {
                                                    System.out.println("Exception " + e.getMessage());
                                                }
                                            }
                                        }
                                        
                                        // classe principale
                                        public class Multithread {
                                            public static void main(String[] args) {
                                                Thread objet = new Thread(new Multithreading());
                                                objet.start();
                                                Thread objet2 = new Thread(new Multithreading());
                                                objet2.start();
                                                for (int i = 0; i < 5; i++) {
                                                    // Le contrôle passe au thread enfant apres 5 itération
                                                    Thread.yield();
                                        
                                                    // Après exécution du thread enfant,
                                                    // le thread main prend le relais
                                                    System.out.println(Thread.currentThread().getName() + " a le controle");
                                                }
                                            }
                                        }
                                
Thread-0 a le controle
Thread-0 a le controle
Thread-0 a le controle
Thread-0 a le controle
Thread-0 a le controle
Thread-1 a le controle
Thread-1 a le controle
Thread-1 a le controle
Thread-1 a le controle
Thread-1 a le controle
main a le controle
main a le controle
main a le controle
main a le controle
main a le controle
Exemple 2 - sleep()
                                        class Multithreading implements Runnable {
                                            public void run() {
                                                try {
                                                    for (int i = 0; i < 3; i++) {
                                                        System.out.println(Thread.currentThread().getName() + "  " + i);
                                                        // bloquer pendant 1000 millisecondes
                                                        Thread.sleep(1000);
                                                    }
                                        
                                                } catch (Exception e) {
                                                    System.out.println("Exception " + e.getMessage());
                                                }
                                            }
                                        }
                                        
                                        // classe principale
                                        public class Multithread {
                                            public static void main(String[] args) {
                                                Thread objet = new Thread(new Multithreading());
                                                objet.start();
                                                Thread objet2 = new Thread(new Multithreading());
                                                objet2.start();
                                            }
                                        }
                                
Thread-0 0
Thread-1 0
Thread-0 1
Thread-1 1
Thread-1 2
Thread-0 2
Exemple 3 - join()
                                        class Multithreading implements Runnable {
                                            public void run() {
                                                try {
                                                    Thread t = Thread.currentThread();
                                                    System.out.print(t.getName());
                                                    System.out.println("  - Etat :  " + t.isAlive());
                                        
                                                } catch (Exception e) {
                                                    System.out.println("Exception " + e.getMessage());
                                                }
                                            }
                                        }
                                        
                                        // classe principale
                                        public class Multithread {
                                            public static void main(String[] args) throws Exception {
                                                Thread objet = new Thread(new Multithreading());
                                                objet.start();
                                        
                                                // attend que ce thread meure,
                                                // ou 1000 millisecondes est dépassées
                                                objet.join(1000);
                                        
                                                System.out.println(" ------------ ");
                                        
                                                System.out.print(objet.getName());
                                                System.out.println("  - Etat :  " + objet.isAlive());
                                            }
                                        }
                                
Thread-0 - Etat : true
------------
Thread-0 - Etat : false
Exemple 4 - interrupt()
                                        class Multithreading implements Runnable {
                                            public void run() {
                                                Thread t = Thread.currentThread();
                                                System.out.println(t.getName() + " est en cours d'execution ");
                                                try {
                                                    while (true) {
                                                        Thread.sleep(1000);
                                                    }
                                                } catch (InterruptedException e) {
                                                    System.out.print(t.getName() + " est interrompu:");
                                                    System.out.println(e.toString());
                                                }
                                            }
                                        }
                                        
                                        // classe principale
                                        public class Multithread {
                                            public static void main(String[] args) {
                                                Thread obj1 = new Thread(new Multithreading());
                                                obj1.start();
                                                // interrompre le thread
                                                if (!obj1.isInterrupted()) {
                                                    obj1.interrupt();
                                                }
                                        
                                                // bloquer jusqu'à la fin des autres thread
                                                System.out.println(obj1.getName() + " avant " + obj1.isAlive());
                                                try {
                                                    obj1.join();
                                                } catch (InterruptedException e) {
                                                }
                                                System.out.println(obj1.getName() + " apres " + obj1.isAlive());
                                            }
                                        }
                                
Thread-0 est en cours d'execution
Thread-0 est interrompu:java.lang.InterruptedException: sleep interrupted
Thread-0 avant true
Thread-0 apres false

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :