Explication détaillée de trois façons d'implémenter le multithreading en Java

Les exemples de cet article partagent trois façons d'implémenter le multi-threading en Java pour votre référence. Le contenu spécifique est le suivant

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
 
public class Main {
 
  public static void main(String[] args) {
    //方法一：继承Thread
    int i = 0;
//    for(; i < 100; i++){
//      System.out.println(Thread.currentThread().getName() + " " + i);
//      if (i == 5) {
//        ThreadExtendsThread threadExtendsThread = new ThreadExtendsThread();
//        threadExtendsThread.start();
//      }
//    }
     
    //方法二：实现Runnable
//    for(i = 0; i < 100; i++){
//      System.out.println(Thread.currentThread().getName() + " " + i);
//      if (i == 5) {
//        Runnable runnable = new ThreadImplementsRunnable();
//        new Thread(runnable).start();
//        new Thread(runnable).start();
//      }
//    }
 
    //方法三：实现Callable接口
    Callable<Integer> callable = new ThreadImplementsCallable();
    FutureTask<Integer> futureTask = new FutureTask<>(callable);
    for(i = 0; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
      if (i == 5) {
        new Thread(futureTask).start();
        new Thread(futureTask).start();
      }
    }
    try {
      System.out.println("futureTask ruturn: " + futureTask.get());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 
}

Méthode 1, héritée de Thread

public class ThreadExtendsThread extends Thread {
  private int i;
  @Override
  public void run() {
    for(; i < 100; i++) {
      System.out.println(getName() + " " + i); 
    }
  }
}

<.>run La méthode est le corps d'exécution du thread et l'objet ThreadExtendsThread est l'objet thread.

Méthode 2, implémentez l'interface Runnable

public class ThreadImplementsRunnable implements Runnable {
  private int i;
  @Override
  public void run() {
    for(; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
  }
}

La méthode run est le corps d'exécution du thread Lorsqu'elle est utilisée, un nouvel objet Thread est utilisé et l'objet Runnable est transmis au Thread. objet comme cible. Et le même objet Runnable peut être utilisé comme cible de plusieurs threads, et ces threads partagent tous les variables d'instance de l'objet Runnable.

Troisième méthode, implémenter l'interface Callable

import java.util.concurrent.Callable;
 
public class ThreadImplementsCallable implements Callable<Integer> {
  private int i;
   
  @Override
  public Integer call() throws Exception {
    for(; i < 100; i++){
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
    return i;
  }
}

L'interface Callable est similaire à l'interface Runnable, mais plus puissante que l'autre. Le corps d'exécution du thread est la méthode d'appel, qui a. une valeur de retour et peut lever des exceptions. Lorsqu'il est utilisé, enveloppez l'objet Callable dans un objet FutureTask et spécifiez le type de valeur de retour via des génériques. Vous pouvez appeler la méthode get de FutureTask ultérieurement pour récupérer le résultat de l'exécution.

Ce qui précède représente l’intégralité du contenu de cet article, j’espère qu’il sera utile à l’étude de chacun.

Pour des explications plus détaillées sur les trois façons d'implémenter le multi-threading en Java et des articles connexes, veuillez faire attention au site Web PHP chinois !