Quelles sont les trois façons de créer des threads en Java ?

Les trois façons de créer des threads en Java sont : 1. Hériter de la classe Thread pour créer un thread ; 2. Implémenter l'interface Runnable pour créer un thread ; 3. Utiliser Callable et Future pour créer un thread.

Java utilise la classe Thread pour représenter les threads, et tous les objets thread doivent être des instances de la classe Thread ou de ses sous-classes. Java peut créer des threads de trois manières, comme suit :

1) Hériter de la classe Thread pour créer des threads

2) Implémenter l'interface Runnable Créer des fils de discussion

3) Utilisez Callable et Future pour créer des fils de discussion

Jetons un coup d'œil à ces trois méthodes de création de fils de discussion respectivement.

-----------------------------Hériter de la classe Thread pour créer un thread--- --- ---------------

Les étapes générales pour créer et démarrer des multi-threads en héritant de la classe Thread sont les suivantes suit

1]D définir une sous-classe de la classe Thread et remplacer la méthode run() de la classe. Le corps de cette méthode est la tâche. que le thread doit terminer, et la méthode run() est également appelée corps d'exécution du thread.

2] Créez une instance de la sous-classe Thread, c'est-à-dire créez un objet thread

3] Démarrez le fil, c'est-à-dire appeler la start()Méthode

Exemple de code

public class MyThread extends Thread{//继承Thread类
　　public void run(){
　　//重写run方法
　　}
}
public class Main {
　　public static void main(String[] args){
　　　　new MyThread().start();//创建并启动线程
　　}
}

------------- ----- ------Implémenter l'interface Runnable pour créer des threads--------------------

En implémentant Runnable Les étapes générales pour créer et démarrer un thread via une interface sont les suivantes :

1] Définir la classe d'implémentation de l'interface Runnable, et également réécrire l'exécution (). Cette méthode run() est la même que la méthode run() dans Thread. ) est également le corps d'exécution du thread

2] Créer une instance de Runnable. classe d'implémentation et utilisez cette instance comme cible de Thread pour créer un objet Thread. Cet objet Thread est le véritable objet thread

3] La troisième partie démarre toujours le thread en appelant. la méthode start() de l'objet thread

Exemple de code :

public class MyThread2 implements Runnable {//实现Runnable接口
　　public void run(){
　　//重写run方法
　　}
}
public class Main {
　　public static void main(String[] args){
　　　　//创建并启动线程
　　　　MyThread2 myThread=new MyThread2();
　　　　Thread thread=new Thread(myThread);
　　　　thread().start();
　　　　//或者    new Thread(new MyThread2()).start();
　　}
}

---------------- -----Créer des fils de discussion à l'aide de Callable et Future-------------- -------

Contrairement à l'interface Runnable, l'interface Callable fournit une méthode call() comme corps d'exécution du thread. La méthode call() est La méthode run() doit être puissante.

》La méthode call() peut avoir une valeur de retour

》La méthode call() peut déclarer que il lève une exception

Java5 fournit l'interface Future pour représenter la valeur de retour de la méthode call() dans l'interface Callable, et fournit une classe d'implémentation FutureTask pour l'interface Future. Cette classe d'implémentation implémente à la fois l'interface Future. et l'interface Runnable, donc peut être utilisée comme cible de la classe Thread. Plusieurs méthodes publiques sont définies dans l'interface Future pour contrôler ses tâches Callable associées.

>boolean Cancel(boolean mayInterruptIfRunning) : View annule la tâche Callable associée au Future

>V get() : Renvoie la valeur de retour de la méthode call() dans Callable, appelez ceci La méthode provoquera le blocage du programme et la valeur de retour doit être obtenue après la fin du thread enfant

>V get(long timeout, TimeUnit unit) : renvoie la valeur de retour de l'appel() méthode dans Callable, bloquant jusqu'au délai d'expiration, aucun retour n'est renvoyé après le délai spécifié TimeoutException

>boolean isDone() : si la tâche Callable est terminée, renvoie True

>. ;boolean isCancelled() : Si la tâche Callable est terminée avant qu'elle ne soit terminée normalement Annuler, renvoyer True

Après avoir introduit les concepts associés, les étapes pour créer et démarrer un fil de discussion avec une valeur de retour sont les suivantes :

1] Créez une classe d'implémentation de l'interface Callable et implémentez la méthode call (), puis créez une instance de la classe d'implémentation (à partir de java8, vous pouvez directement utiliser des expressions Lambda pour créer des objets Callable).

2] Utilisez la classe FutureTask pour envelopper l'objet Callable, qui encapsule la valeur de retour de la méthode call() de l'objet Callable

3 】Utilisez l'objet FutureTask comme cible de l'objet Thread pour créer et démarrer le thread (car FutureTask implémente l'interface Runnable)

4] Appelez la méthode get() du Objet FutureTask pour obtenir le résultat après l'exécution du sous-thread Valeur de retour de

Exemple de code :

public class Main {
　　public static void main(String[] args){
　　　MyThread3 th=new MyThread3();
　　　//使用Lambda表达式创建Callable对象
　　   //使用FutureTask类来包装Callable对象
　　　FutureTask<Integer> future=new FutureTask<Integer>(
　　　　(Callable<Integer>)()->{
　　　　　　return 5;
　　　　}
　　  );
　　　new Thread(task,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程
　　  try{
　　　　System.out.println("子线程的返回值："+future.get());//get()方法会阻塞，直到子线程执行结束才返回
 　　 }catch(Exception e){
　　　　ex.printStackTrace();
　　　}
　　}
}

---------- --------------- -------------Comparaison de trois méthodes de création de threads------------------- ------------------- -------

Les façons d'implémenter Runnable et l'interface Callable sont fondamentalement les mêmes, sauf que cette dernière a une valeur de retour lors de l'exécution de la méthode call(), et cette dernière n'a pas de valeur de retour lorsque le corps d'exécution du thread run() renvoie la valeur, donc ces deux méthodes peuvent être classées en une seule. la méthode héritant de la classe Thread est la suivante :

1. Les threads implémentent uniquement l'interface Runnable ou Callable et peuvent également hériter d'autres classes.

2. De cette façon, plusieurs threads peuvent partager un objet cible, ce qui est très approprié pour les situations où plusieurs threads traitent la même ressource.

3. Cependant, la programmation est légèrement compliquée. Si vous avez besoin d'accéder au thread actuel, vous devez appeler la méthode Thread.currentThread().

4. Une classe thread qui hérite de la classe Thread ne peut pas hériter d'autres classes parents (décision d'héritage unique Java).

Remarque : Il est généralement recommandé de créer des multi-threads en implémentant des interfaces

Pour plus de connaissances liées à la programmation, veuillez visiter : Cours vidéo de programmation! !

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!