Detailed explanation of three ways to implement multi-threading in Java

The examples in this article share three ways to implement multi-threading in Java for your reference. The specific content is as follows

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

Method 1, inherited from Thread

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

The run method is thread execution body, the ThreadExtendsThread object is the thread object.

Method 2, implement the Runnable interface

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

The run method is the thread execution body. When used, a New Thread object is used, and the Runnable object is passed to the Thread object as the target. And the same Runnable object can be used as the target of multiple Threads, and these threads all share the instance variables of the Runnable object.

Method 3, implement the Callable interface

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

The Callable interface is similar to the Runnable interface, but more powerful than the other. The thread execution body is the call method, which has a return value and can throw exceptions. When used, wrap the Callable object into a FutureTask object and specify the return value type through generics. You can call the get method of FutureTask later to retrieve the execution result.

The above is the entire content of this article, I hope it will be helpful to everyone's study.

For more detailed explanations of the three ways to implement multi-threading in Java, please pay attention to the PHP Chinese website for related articles!