3 façons de créer des threads en Java et leurs différences

Comment créer un fil de discussion en java ? L'article suivant vous présentera 3 façons de créer des fils de discussion et leurs différences. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Si vous souhaitez créer un thread en java, il existe généralement trois méthodes :

1. Hériter de la classe Thread

. 2. Implémentez l'interface Runnable ;

3. Utilisez Callable et Future pour créer des threads.

[Apprentissage recommandé : Tutoriel vidéo Java]

Hériter de la classe Thread

Hériter Pour la classe Thread, vous devez remplacer la méthode run et définir les tâches qui doivent être effectuées dans la méthode run.

class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

Après avoir créé votre propre classe de thread, vous pouvez créer un objet thread, puis démarrer le thread via la méthode start(). Notez que la méthode run() n'est pas appelée pour démarrer le thread. La méthode run définit uniquement les tâches qui doivent être effectuées. Si la méthode run est appelée, cela équivaut à exécuter la méthode run dans le thread principal. Aucune différence avec les appels de méthode ordinaires. Pour le moment, il n'y a pas de Un nouveau thread sera créé pour effectuer les tâches définies.

public class Test {
    public static void main(String[] args)  {
        MyThread thread = new MyThread();
        thread.start();
    }
}
 
 
class MyThread extends Thread{
    private static int num = 0;
     
    public MyThread(){
        num++;
    }
     
    @Override
    public void run() {
        System.out.println("主动创建的第"+num+"个线程");
    }
}

Dans le code ci-dessus, en appelant la méthode start(), un nouveau thread sera créé. Afin de distinguer la différence entre l'appel de méthode start() et l'appel de méthode run(), veuillez regarder l'exemple suivant :

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID:"+Thread.currentThread().getId());
        MyThread thread1 = new MyThread("thread1");
        thread1.start();
        MyThread thread2 = new MyThread("thread2");
        thread2.run();
    }
}
 
 
class MyThread extends Thread{
    private String name;
     
    public MyThread(String name){
        this.name = name;
    }
     
    @Override
    public void run() {
        System.out.println("name:"+name+" 子线程ID:"+Thread.currentThread().getId());
    }
}

Résultats d'exécution :

À partir des résultats de sortie, les conclusions suivantes peuvent être tirées :

1) Les ID de thread du thread1 et du thread2 sont différents, et le thread2 et l'ID du thread principal sont les mêmes, indiquant que l'appel de la méthode run ne ne crée pas un nouveau thread, mais s'exécute directement dans le thread principal. La méthode run n'est pas différente des appels de méthode ordinaires

2) Bien que la méthode start du thread1 soit appelée avant la méthode run du thread2, les informations lié à l'appel de la méthode run du thread2 est affiché en premier, indiquant que le nouveau processus de création du thread ne bloquera pas l'exécution ultérieure du thread principal.

2. Implémenter l'interface Runnable

En plus d'hériter de la classe Thread, la création d'un thread en Java peut également obtenir quelque chose de similaire en implémentant la fonction d'interface Runnable. L'implémentation de l'interface Runnable doit remplacer sa méthode run.

Ce qui suit est un exemple :

public class Test {
    public static void main(String[] args)  {
        System.out.println("主线程ID："+Thread.currentThread().getId());
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}
 
 
class MyRunnable implements Runnable{
     
    public MyRunnable() {
         
    }
     
    @Override
    public void run() {
        System.out.println("子线程ID："+Thread.currentThread().getId());
    }
}

La signification chinoise de Runnable est "tâche". Comme son nom l'indique, en implémentant l'interface Runnable, nous définissons une sous-tâche puis la transmettons. vers Thread pour exécution. Notez que cette méthode doit utiliser Runnable comme paramètre de la classe Thread, puis utiliser la méthode start de Thread pour créer un nouveau thread afin d'effectuer la sous-tâche. Si vous appelez la méthode run de Runnable, aucun nouveau thread ne sera créé. Cet appel de méthode ordinaire ne fait aucune différence.

En fait, si vous regardez le code source d'implémentation de la classe Thread, vous constaterez que la classe Thread implémente l'interface Runnable.

En Java, ces deux méthodes peuvent être utilisées pour créer des threads pour effectuer des sous-tâches. La méthode à choisir dépend de vos propres besoins. Hériter directement de la classe Thread peut sembler plus simple que d'implémenter l'interface Runnable, mais comme Java n'autorise qu'un seul héritage, si une classe personnalisée doit hériter d'autres classes, elle ne peut choisir d'implémenter que l'interface Runnable.

3. Utilisez Callable et Future pour créer des threads

Contrairement à l'interface Runnable, l'interface Callable fournit une méthode call() pour l'exécution des threads. body, la méthode call() est plus puissante que la méthode run().

Les étapes pour créer et démarrer un thread avec une valeur de retour sont les suivantes :

1. Créez une classe d'implémentation de l'interface Callable, 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émarrez le thread (car FutureTask a implémenté l'interface Runnable)
4. Appelez la méthode get() de l'objet FutureTask pour obtenir la valeur de retour après l'exécution du sous-thread

Le voici un exemple :

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 façons de créer des threads :

Les méthodes d'implémentation des interfaces Runnable et Callable sont fondamentalement les mêmes , mais cette dernière a une valeur de retour lors de l'exécution de la méthode call(). La méthode run() du corps d'exécution du thread n'a pas de valeur de retour, ces deux méthodes peuvent donc être classées en une seule. la classe Thread est la suivante :

1. Les threads implémentent uniquement Runnable ou implémentent l'interface Callable et héritent 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).

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

Cet article provient de la rubrique Introduction Java, bienvenue pour apprendre !

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!