Quelles sont les manières de créer des threads en Java ? Trois façons de créer des threads en Java

Ce que cet article vous apporte, c'est quelles sont les manières de créer des threads en Java ? Les trois façons de créer des threads en Java ont une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère que cela vous sera utile.

1. Héritez de la classe Thread pour créer

En héritant de Thread et en réécrivant son run(), le thread exécute la tâche dans la méthode run. La sous-classe créée peut exécuter des méthodes de thread en appelant la méthode start().

En héritant de la classe de thread implémentée par Thread, plusieurs threads ne peuvent pas partager les variables d'instance de la classe de thread. (Besoin de créer différents objets Thread, naturellement non partagés)

Exemple :

/**
 * 通过继承Thread实现线程
 */
public class ThreadTest extends Thread{
　　
　　private int i = 0 ;

    @Override
    public void run() {
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " is running " + i );
        }
    }

    public static void main(String[] args) {
        for(int j=0;j<50;j++){if(j=20){
                new ThreadTest().start() ;
                new ThreadTest().start() ;
            }
        }
    }
}

2. Créer des fils de discussion via Runnable interface Class

Cette méthode doit d'abord définir une classe pour implémenter l'interface Runnable et remplacer la méthode run() de l'interface. Cette méthode run est le corps d'exécution du thread. Créez ensuite un objet de la classe d'implémentation Runnable comme cible de paramètre pour créer l'objet Thread Cet objet Thread est le véritable objet thread. Les classes Thread qui implémentent l'interface Runnable partagent des ressources entre elles.

/**
 * 通过实现Runnable接口实现的线程类
 */
public class RunnableTest implements Runnable {
    private int i ;
    @Override
    public void run() {
        for(;i<50;i++){
            System.out.println(Thread.currentThread().getName() + " -- " + i);
        }
    }
    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName() + " -- " + i);
            if(i==20){
                RunnableTest runnableTest = new RunnableTest() ;
                new Thread(runnableTest,"线程1").start() ;
                new Thread(runnableTest,"线程2").start() ;
            }
        }
    }
}

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

Comme le montre l'héritage de la classe Thread et l'implémentation. l'interface Runnable, aucune des deux méthodes ci-dessus ne peut avoir de valeur de retour et ne peut pas être déclarée pour lever une exception. L'interface Callable réalise ces deux points. L'interface Callable est comme une version améliorée de l'interface Runable. La méthode call() qu'elle fournit servira de corps d'exécution du thread et permettra une valeur de retour.

Mais l'objet Callable ne peut pas être directement utilisé comme cible de l'objet Thread, car l'interface Callable est une nouvelle interface dans Java 5 et n'est pas une sous-interface de l'interface Runnable. La solution à ce problème consiste à introduire l'interface Future, qui peut accepter la valeur de retour de call(). L'interface Future est une sous-interface de l'interface Runnable et peut être utilisée comme cible de l'objet Thread. De plus, l'interface Future fournit une classe d'implémentation : FutureTask.

FutureTask implémente l'interface Future et l'interface Runnable et peut être utilisée comme cible de l'objet Thread.

La relation est la suivante :

Exemple :

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class CallableTest {
    public static void main(String[] args) {
        CallableTest callableTest = new CallableTest() ;
        //因为Callable接口是函数式接口，可以使用Lambda表达式
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
           int i = 0 ;
           for(;i<100;i++){
               System.out.println(Thread.currentThread().getName() + "的循环变量i的值 ：" + i);
           }
           return i;
        });
       for(int i=0;i<100;i++){
           System.out.println(Thread.currentThread().getName()+" 的循环变量i ： + i");
           if(i==20){
               new Thread(task,"有返回值的线程").start();
           }
       }
       try{
           System.out.println("子线程返回值 ： " + task.get());
        }catch (Exception e){
           e.printStackTrace();
        }
    }
}

Résumé

Grâce aux trois méthodes ci-dessus, elles peuvent en fait être classées en deux catégories : hériter de classes et implémenter des interfaces. Par rapport à l'héritage, l'implémentation de l'interface peut être plus flexible et ne sera pas limitée par le mécanisme d'héritage unique de Java. Et les ressources peuvent être partagées en implémentant des interfaces, ce qui convient au traitement multithread de la même ressource. La connaissance des threads est riche et compliquée, et plus de détails doivent être appris et maîtrisés.

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!