Thread démon en Java

Le thread démon en Java est un thread qui a la priorité la plus basse et est utilisé pour fournir des services au thread, qui est ensuite utilisé pour effectuer les tâches en arrière-plan. L'exécution de tâches en arrière-plan inclut le garbage collection et de nombreuses autres tâches qui impliquent que JVM s'empêche au moment de l'exécution simultanément après la sortie. La machine virtuelle Java se termine lorsqu'elle trouve d'autres threads utilisateur qui ne sont pas réellement les threads démons. Si la machine virtuelle Java trouve un thread démon, elle mettra d'abord fin à ce thread, puis elle sera elle-même arrêtée.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

Il n'y a pas de syntaxe spécifique pour le Daemon Thread, mais il peut être créé et appelé par d'autres méthodes dans le cadre du Daemon Thread, qui est représenté comme :

public class DaemonThread extends Thread

• Classe publique : Le modificateur d'accès de la classe est public et
• DaemonThread : Le type de thread est DaemonThread, il est donc hérité et étendu de la classe Thread.
• Thread : La classe thread est utilisée pour hériter des propriétés de la classe Thread au thread Daemon.

De plus, cela implique diverses méthodes qui ont une syntaxe différente pour appeler le thread Daemon.

public final void setDaemon(boolean on)

Cette syntaxe de méthode transmet le paramètre comme booléen sur lequel est utilisé car le thread est un thread démon lorsque le thread démon est marqué comme booléen sur ce qui signifie vrai.

public final boolean isDaemon()

Cette méthode renvoie la valeur comme true si le thread trouvé est un thread démon et false si le thread trouvé est faux.

Comment fonctionne Daemon Thread en Java ?

Un thread démon est un thread utilisé pour créer un thread et hérite de toutes les propriétés de son thread parent. Par conséquent, tous les threads présents dans la méthode principale sont appelés méthode enfant, qui hérite de la plupart des propriétés d'exécution et d'exécution de n'importe quelle tâche de la classe parent. Ils sont également appelés threads non-démons.

Voici la vraie image de la création de threads non-démons ou de threads utilisateur en tant que threads démons en appelant toutes les méthodes permettant de définir le thread en tant que threads démon. Il peut facilement être défini comme un thread Daemon à l'aide de la méthode setDaemon() de la classe Thread, qui est la classe à partir de laquelle l'interface exécutable est également étendue.

Un point très important à garder à l'esprit est que chaque fois qu'une JVM démarre, à ce moment-là, un thread appelé main est créé, et tout programme est exécuté ou démarré à ce stade, ou nous pouvons dire que c'est le point où le flux d’exécution commence. Par défaut, tous les threads s'exécuteront sur ce thread principal jusqu'à ce qu'un nouveau thread soit lancé. Dans le cas où un nouveau fil de discussion est lancé, le fil de discussion enfant sera responsable de la création de toute nouvelle méthode.

Vient ensuite les méthodes responsables de la création et de la détermination des threads démons, qui impliquent des méthodes comme la méthode setDaemon, qui déterminera si le thread créé est un thread démon ou un thread non-démon en fonction de la valeur du paramètre transmis à la méthode.

Le thread booléen public isDaemon() est utilisé en revanche pour vérifier l'état du thread en fonction du type de retour ; si faux, alors le thread n'est pas un démon ; sinon, c'est un démon.

Méthodes

Voici les méthodes mentionnées ci-dessous

1. public void setDaemon (statut booléen)

Cette méthode est utilisée pour transformer l'exécution du thread actuel en thread démon en fonction du paramètre passé s'il est booléen, alors le thread est un thread démon si le paramètre passé n'est pas booléen, alors le thread est le thread non-démon .

Il détecte également les exceptions qui sont comme IllegalThreadStateException ou Security Exception. S’il est déterminé qu’il faut intercepter une exception illégaleThreadStateException, il est alors nécessaire que le thread soit uniquement actif. Si le fil de discussion actuel ne peut pas être modifié, il utilisera une exception de sécurité.

2. public booléen isDaemon()

Cette méthode est utilisée pour vérifier la situation actuelle ou indiquer l'état actuel en fonction du type de retour ; si le type de retour est vrai, alors il s'agit d'un thread démon ; sinon, c'est le fil non-démon.

Exemples de thread démon en Java

Voici les exemples suivants mentionnés ci-dessous :

Exemple n°1

Ce programme montre la méthode de définition du thread comme thread démon pour une manipulation ultérieure en utilisant la méthode void setDaemon (statut booléen) et isDaemon() une fois appelée après avoir identifié le thread démon, qui indique si l'ensemble de threads est un thread démon ou le thread non-démon en fonction du paramètre défini avec une valeur booléenne pour le paramètre.

Code :

public class Daemon_Thread_Demo_set extends Thread {
public Daemon_Thread_Demo_set(String nm){
super(nm);
}
public void run()
{
if(Thread.currentThread().isDaemon())
{
System.out.println("Current_Thread is a Daemon thread" + Thread.currentThread().getName());
}
else
{
System.out.println("Current thread is a non-daemon thread. "+ Thread.currentThread().getName());
}
}
public static void main(String[] args) {
Daemon_Thread_Demo_set nm1 = new Daemon_Thread_Demo_set("nm1");
Daemon_Thread_Demo_set nm2 = new Daemon_Thread_Demo_set("nm2");
Daemon_Thread_Demo_set nm3 = new Daemon_Thread_Demo_set("nm3");
nm1.setDaemon(true);
nm1.start();
nm2.start();
nm3.setDaemon(false);
nm3.start();
}
}

Sortie :

Example #2

This program demonstrates the illegal exceptions which are thrown once the current thread is identified as the Daemon thread but then the value when the set is not coming out to be set value matched with the thread it will be throwing the illegal exception as represented in the output.

Code:

public class Daemon_thrd_demo2 extends Thread {
public void run()
{
System.out.println("Current_thread_Name: "+Thread.currentThread().getName());
System.out.println("thread_as_Daemon"+Thread.currentThread().isDaemon());
}
public static void main(String[] args) {
Daemon_thrd_demo2 tst1 = new Daemon_thrd_demo2();
Daemon_thrd_demo2 tst2 = new Daemon_thrd_demo2();
tst1.start();
tst1.setDaemon(true);
tst2.start();
}
}

Output:

Note: The above program gives the Exception because the user thread should be set as a daemon thread only before calling the setDaemon() method. If it is not called in this way, then the thread after invocation will throw these exceptions while execution. Also, all non-daemon thread and daemon thread should be set up keeping in mind the place, i.e. before the child class or before the parent class.

Conclusion

Daemon thread and non-daemon thread have differences in them. It is very important to identify these differences as it can lead to conflicts and exception because daemon thread is a kind of thread that has the lowest priority compared to other threads while execution.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!