Introduction à 3 méthodes de création de threads en Java (code)

Ce que cet article vous apporte est une introduction (code) aux trois méthodes de création de threads en Java. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

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émentation de l'interface Runnable

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

1. Hériter de la classe Thread

Si vous héritez de la classe Thread, vous devez remplacer la méthode run et définir les tâches qui doivent être effectué 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ésultat de l'exécution :

Les conclusions suivantes peuvent être tirées des résultats de sortie :

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 du La méthode run ne crée pas de nouveau thread, mais dans L'exécution de la méthode run directement dans le thread principal 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 ; , la première sortie est la méthode d'exécution du thread2 Informations associées, indiquant que le processus de création d'un nouveau thread ne bloquera pas l'exécution ultérieure du thread principal.

2. Implémentez l'interface Runnable

En plus d'hériter de la classe Thread lors de la création d'un thread en Java, vous pouvez également implémenter des fonctions similaires en implémentant l'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 passons. la sous-tâche à Thread à exécuter. 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() comme corps d'exécution du thread, l'appel( ) méthode Elle 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éer une classe d'implémentation de l'interface Callable, implémenter la méthode call(), puis créez l'instance de classe d'implémentation (à partir de java8, vous pouvez directement utiliser des expressions Lambda pour créer des objets appelables).

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. Utiliser l'objet FutureTask Créer et démarrer un thread comme cible de l'objet Thread (car FutureTask implémente l'interface Runnable)

4. Appelez la méthode get() de l'objet FutureTask pour obtenir la valeur de retour une fois l'exécution du fil enfant terminée

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 fils :

Implémentation de Runnable et implémentation de Callable Les méthodes de l'interface 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 lors de l'exécution de la méthode call(). run() du corps d'exécution du thread. Par conséquent, ces deux méthodes peuvent être classées en une seule. Cette méthode est similaire à l'héritage de la classe Thread. Les différences entre les méthodes sont les suivantes :

<.>Les threads implémentent uniquement Runnable ou implémentent l'interface Callable, et peuvent également hériter d'autres classes.
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.
Mais 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().
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 du multi-threads en implémentant des interfaces

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!