Java多線程實現方法詳解

Java作為一門高級編程語言，支持多線程的編程模型。在Java程序中，啟動多個線程可以幫助我們實現並行計算及非同步操作等功能。

一、線程實現方法

Java多線程有幾種實現方法，包括繼承Thread類、實現Runnable介面、使用Executor框架、使用Callable和Future、使用同步器及Lock等方法。

二、繼承Thread類

繼承Thread類是Java中最古老、最簡單的線程實現方式。通過繼承Thread類，可以重寫run()方法來定義線程的執行邏輯。下面是一個簡單的實現示例：

public class ThreadDemo extends Thread {
  public void run() {
    System.out.println("Hello, I am a thread!");
  }

  public static void main(String[] args) {
    ThreadDemo demo = new ThreadDemo();
    demo.start();
  }
}

在上面的示例中，ThreadDemo類繼承了Thread類，並重寫了run()方法。在main()方法中，我們實例化了一個ThreadDemo對象，並調用start()方法來啟動線程。線程啟動後，會在run()方法中執行自定義的邏輯。

三、實現Runnable介面

實現Runnable介面是Java中常用的線程實現方式之一。與繼承Thread類相比，這種方式可以避免單繼承的限制，並且實現更加面向對象。下面是一個實現Runnable介面的示例：

public class RunnableDemo implements Runnable {
  public void run() {
    System.out.println("Hello, I am a thread!");
  }

  public static void main(String[] args) {
    RunnableDemo demo = new RunnableDemo();
    Thread thread = new Thread(demo);
    thread.start();
  }
}

在上面的示例中，RunnableDemo類實現了Runnable介面，並重寫了run()方法。在main()方法中，我們實例化了一個RunnableDemo對象，並將其傳遞給Thread的構造函數來創建一個新的線程。線程啟動後，會在run()方法中執行自定義的邏輯。

四、使用Executor框架

使用Executor框架提供的線程池可以更加方便地管理多個線程。Java中提供了ExecutorService介面和ThreadPoolExecutor類來實現線程池，下面是一個使用線程池的示例：

public class ExecutorDemo {
  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
      executor.execute(new Runnable() {
        public void run() {
          System.out.println("Hello, I am a thread!");
        }
      });
    }
    executor.shutdown();
  }
}

在上面的示例中，我們使用Executors.newFixedThreadPool()方法創建了一個固定大小為3的線程池。然後使用execute()方法提交10個任務，每個任務都會輸出一個Hello語句。最後，我們調用executor.shutdown()方法關閉線程池。

五、使用Callable和Future

Callable和Future是Java 5中新增的線程實現機制。Callable介面有一個call()方法，可以返回線程執行的結果。Future介面可以用來獲取線程執行結果或者取消線程的執行。下面是一個使用Callable和Future的示例：

public class CallableDemo implements Callable {
  public Integer call() throws Exception {
    int sum = 0;
    for (int i = 0; i < 10; i++) {
      sum += i;
    }
    return sum;
  }

  public static void main(String[] args) throws Exception {
    CallableDemo demo = new CallableDemo();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future future = executor.submit(demo);
    int result = future.get();
    System.out.println(result);
    executor.shutdown();
  }
}

在上面的示例中，CallableDemo類實現了Callable介面，並實現了call()方法。在main()方法中，我們實例化了一個CallableDemo對象，並使用ExecutorService.submit()方法提交任務。submit()方法會返回一個Future對象，我們可以使用get()方法來獲取線程執行的結果，結果類型為定義的泛型類型。最後，我們關閉線程池。

六、使用同步器及Lock

同步器是Java中用來協調多個線程之間同步運行的機制。Java提供了多種同步器，包括synchronized關鍵字、Lock介面及讀寫鎖等。下面是一個使用Lock介面實現同步的示例：

public class LockDemo implements Runnable {
  private final Lock lock = new ReentrantLock();

  public void run() {
    lock.lock();
    try {
      System.out.println("Hello, I am a thread!");
    } finally {
      lock.unlock();
    }
  }

  public static void main(String[] args) {
    LockDemo demo = new LockDemo();
    Thread thread = new Thread(demo);
    thread.start();
  }
}

在上面的示例中，LockDemo類實現了Runnable介面，並實現了run()方法。運行時，我們使用ReentrantLock類實例化了一個鎖，然後在run()方法中先獲取鎖，執行一些操作，最後釋放鎖。在main()方法中，我們實例化了LockDemo對象，並啟動了一個新的線程。