Résumé de plusieurs façons d'implémenter le multithreading en Java

Regardons d'abord un exemple de code

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();
    }
  }
 
}

Ensuite, discutons en détail de plusieurs façons d'implémenter le multi-threading en Java

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); 
    }
  }
}

La méthode run 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.

Pour plus de méthodes Java pour implémenter le multi-threading, veuillez faire attention au site Web PHP chinois pour les articles connexes !