Java多線程入門類和接口.png

引言

大家好，我是你們的老伙計秀才！今天帶來的是[深入淺出Java多線程]系列的第二篇內(nèi)容：Java多線程類和接口。大家覺得有用請點贊，喜歡請關(guān)注！秀才在此謝過大家了！??！

在現(xiàn)代計算機系統(tǒng)中，多線程技術(shù)是提升程序性能、優(yōu)化資源利用和實現(xiàn)并發(fā)處理的重要手段。特別是在Java編程語言中，多線程機制被深度集成并廣泛應(yīng)用于高并發(fā)場景，如服務(wù)器響應(yīng)多個客戶端請求、大規(guī)模數(shù)據(jù)處理以及用戶界面的實時更新等。理解并熟練掌握Java中的多線程創(chuàng)建與管理方式，不僅能幫助開發(fā)者充分利用硬件資源，還能有效避免競態(tài)條件、死鎖等并發(fā)問題，確保應(yīng)用程序在多核處理器架構(gòu)下運行得更為高效且穩(wěn)定。

本文將深入探討Java多線程編程的基本概念和技術(shù)細節(jié)。首先從最基礎(chǔ)的Thread類入手，介紹如何通過繼承Thread類或?qū)崿F(xiàn)Runnable接口來定義并啟動一個線程，強調(diào)start()方法對于激活線程執(zhí)行的關(guān)鍵作用，并對比兩種實現(xiàn)方式的優(yōu)劣。同時，我們將揭開Thread類構(gòu)造方法背后的秘密，詳述各個參數(shù)的意義及初始化過程。

進一步地，文檔將闡述Thread類中的一系列常用方法，包括獲取當前線程引用的currentThread()方法、啟動線程執(zhí)行邏輯的start()方法、釋放CPU時間片的yield()方法、控制線程暫停執(zhí)行的sleep()方法，以及用于同步等待其他線程完成的join()方法。通過對這些方法的詳細解讀，讀者能夠更好地掌握Java線程間的協(xié)作和調(diào)度原理。

此外，為了滿足異步任務(wù)執(zhí)行和結(jié)果返回的需求，Java提供了Callable接口及其配套的Future和FutureTask類。Callable允許我們在新的線程中執(zhí)行有返回值的任務(wù)，而Future作為異步計算的結(jié)果容器，可以用來查詢?nèi)蝿?wù)是否完成、取消正在執(zhí)行的任務(wù)以及獲取計算結(jié)果。FutureTask則是對Future接口和Runnable接口功能的完美融合，它不僅封裝了任務(wù)的執(zhí)行邏輯，還提供了一種便捷的方式來管理和跟蹤異步操作的狀態(tài)。

綜上所述，本文旨在引導逐步了解和掌握Java多線程編程的核心類與接口，并通過實際示例解析它們的工作機制和應(yīng)用場景，為開發(fā)高性能、高并發(fā)的Java應(yīng)用程序奠定堅實的基礎(chǔ)。接下來的內(nèi)容將逐一展開對上述關(guān)鍵知識點的詳細講解。

Java中創(chuàng)建與啟動線程

Java中創(chuàng)建與啟動線程（約800字）

在Java中，我們可以通過繼承Thread類或?qū)崿F(xiàn)Runnable接口來創(chuàng)建自定義的線程對象，并通過調(diào)用start()方法啟動執(zhí)行。這兩種方式分別具有不同的應(yīng)用場景和特點。

繼承Thread類
通過直接繼承Thread類并重寫run()方法，可以便捷地創(chuàng)建一個具備特定任務(wù)邏輯的線程。以下是一個簡單的示例：

public class MyCustomThread extends Thread {
    @Override
    public void run() {
        System.out.println("Inheriting from Thread class: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyCustomThread myThread = new MyCustomThread();
        myThread.start(); // 啟動線程
    }
}

在這個例子中，MyCustomThread繼承了Thread類并覆蓋了run()方法，當調(diào)用start()方法時，JVM會為該線程分配資源并安排它在適當?shù)臅r候執(zhí)行run()方法中的代碼。

注意：每個線程只能調(diào)用一次start()方法。如果試圖再次調(diào)用start()，將會拋出IllegalThreadStateException異常。這是因為一旦線程開始運行后，其生命周期已經(jīng)進入執(zhí)行階段，不能重復初始化和啟動。

實現(xiàn)Runnable接口
相較于繼承Thread類，實現(xiàn)Runnable接口更為靈活，因為Java語言遵循單繼承原則，而接口可以多重實現(xiàn)。這使得我們的類可以在繼承其他類的同時實現(xiàn)多線程功能。以下是使用Runnable接口創(chuàng)建線程的示例：

public class RunnableTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Implementing Runnable interface: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        RunnableTask task = new RunnableTask();
        Thread thread = new Thread(task, "MyRunnableThread");
        thread.start();
    }
}

在上述代碼中，RunnableTask實現(xiàn)了Runnable接口并提供了run()方法的具體實現(xiàn)。然后，我們將RunnableTask實例傳給Thread類的構(gòu)造函數(shù)，創(chuàng)建了一個新的線程，并通過thread.start()來啟動它。

此外，從Thread類的源碼分析可知，Thread類是Runnable接口的一個實現(xiàn)類，其構(gòu)造方法接收Runnable類型的參數(shù)target，并通過內(nèi)部的init方法對其進行初始化。這樣，無論我們是繼承Thread還是實現(xiàn)Runnable，最終都是為了提供一個Runnable實例給Thread來執(zhí)行具體的任務(wù)邏輯。

總結(jié)來說，Java提供了兩種途徑創(chuàng)建線程，各有優(yōu)劣。繼承Thread類的方式直觀簡潔，適用于輕量級的線程封裝；而實現(xiàn)Runnable接口則更符合面向?qū)ο笤O(shè)計原則，避免了類層次結(jié)構(gòu)的限制，提高了代碼的可復用性和靈活性。在實際編程中，推薦優(yōu)先考慮實現(xiàn)Runnable接口以保持代碼結(jié)構(gòu)清晰、易擴展。

Thread類構(gòu)造方法詳解

在Java中，Thread類的構(gòu)造方法是創(chuàng)建線程對象并為其設(shè)置屬性的核心途徑。Thread類提供了多個構(gòu)造函數(shù)以滿足不同場景下的初始化需求，但它們最終都會調(diào)用到一個私有的init方法來完成線程對象的初始化。

// Thread類的部分源碼片段：
private void init(ThreadGroup g, Runnable target, String name,
                        long stackSize, AccessControlContext acc,
                        boolean inheritThreadLocals) {...}

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

上述代碼揭示了Thread類的一個重要構(gòu)造方法：接受一個Runnable類型的target參數(shù)，用于指定線程要執(zhí)行的任務(wù)；同時為新創(chuàng)建的線程生成一個默認名稱，并分配默認的棧大小。當通過這個構(gòu)造器實例化Thread對象時，會調(diào)用內(nèi)部的init方法進行詳細的初始化操作：

• g: ThreadGroup - 線程組，若不指定，默認值為null，表示線程將加入到當前應(yīng)用程序的主要線程組中。
• target: Runnable - 這個參數(shù)至關(guān)重要，它定義了線程執(zhí)行體，即run()方法的具體內(nèi)容。當我們實現(xiàn)Runnable接口或者繼承Thread類重寫run()方法時，實際就是給target賦值。
• name: String - 指定線程的名字，如果沒有提供名字，則系統(tǒng)會自動為其生成一個唯一的線程名。
• stackSize: long - 棧的大小，通常情況下我們不會顯式設(shè)置線程棧大小，這里使用默認值0，由JVM自行決定合適的?？臻g大小。
• acc: AccessControlContext - 安全控制上下文，用于控制線程執(zhí)行權(quán)限，這是一個相對復雜且較少直接使用的概念，主要用于安全管理框架，如Java安全模型中的訪問控制列表等。
• inheritThreadLocals: boolean - 控制線程是否從父線程繼承ThreadLocal變量。在多線程環(huán)境下，ThreadLocal可以為每個線程維護一個獨立的變量副本，此處涉及到線程局部變量的傳遞問題。

此外，Thread類內(nèi)部還包含了與ThreadLocal相關(guān)的兩個私有屬性threadLocals和inheritableThreadLocals，它們用于支持線程間的數(shù)據(jù)隔離以及特定情況下的線程本地變量繼承。

總之，通過Thread類的構(gòu)造方法，我們可以靈活地定制線程的各種屬性，包括任務(wù)目標、線程名以及其他可能影響線程行為的因素。這些構(gòu)造方法的設(shè)計充分體現(xiàn)了Java對線程管理的靈活性和可配置性。

Thread類常用方法

在Java中，Thread類提供了多種方法來管理和控制線程的生命周期及行為。以下將詳細解析Thread類的幾個核心方法，并對比使用Runnable接口與繼承Thread類創(chuàng)建線程的方式。

Thread類的常用方法

• currentThread(): 這是一個靜態(tài)方法，返回對當前正在執(zhí)行的線程對象的引用。例如：

  Thread currentThread = Thread.currentThread();
  System.out.println(currentThread.getName());
  
  

  通過這個方法可以獲取當前線程信息并進行相應(yīng)的操作。

• start(): 用于啟動一個線程，使其從新建狀態(tài)進入就緒狀態(tài)，然后等待操作系統(tǒng)調(diào)度執(zhí)行。調(diào)用start()方法后，虛擬機內(nèi)部會調(diào)用該線程的run()方法。多次調(diào)用start()會導致異常，因此確保只調(diào)用一次。

• yield(): 表示當前線程愿意放棄CPU時間片，使其他同等優(yōu)先級的線程有機會運行。但這并不是強制性的，實際調(diào)度結(jié)果取決于JVM和操作系統(tǒng)的實現(xiàn)。

  Thread t1 = new Thread(() -> {
      for (int i = 0; i < 5; i++) {
          Thread.yield();
          System.out.println(Thread.currentThread().getName() + ": " + i);
      }
  });
  t1.start();
  
  

• sleep(long millis): 讓當前線程暫停指定毫秒數(shù)的時間，交出CPU使用權(quán)給其他線程。此方法會拋出InterruptedException，需妥善處理。

• join(): 使當前線程等待另一個線程結(jié)束。當在一個線程上調(diào)用t.join()時，當前線程將被阻塞直到線程t完成其任務(wù)。

  Thread threadA = new Thread(() -> {
      // 執(zhí)行耗時任務(wù)
  });
  Thread threadB = new Thread(() -> {
      try {
          threadA.join(); // 等待threadA執(zhí)行完畢
          System.out.println("Thread B continues after A");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  });
  
  threadA.start();
  threadB.start();
  
  

Thread類與Runnable接口的比較

• 繼承Thread類的方式可以直接訪問Thread類中的諸多方法，但受到Java單繼承的限制，若需要擴展已有類則不適用。
• 實現(xiàn)Runnable接口更符合面向?qū)ο笤瓌t，因為Runnable是接口，可以實現(xiàn)多繼承，降低了線程對象和線程任務(wù)之間的耦合度。并且，采用Runnable時，可以通過靈活組合Thread類的各種構(gòu)造方法來創(chuàng)建線程實例。

例如，考慮以下兩個實現(xiàn)方式：

// 繼承Thread類方式
public class MyThread extends Thread {
    @Override
    public void run() {
        // 線程執(zhí)行邏輯
    }

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

// 實現(xiàn)Runnable接口方式
public class RunnableTask implements Runnable {
    @Override
    public void run() {
        // 線程執(zhí)行邏輯
    }

    public static void main(String[] args) {
        RunnableTask task = new RunnableTask();
        Thread thread = new Thread(task, "MyRunnableThread");
        thread.start();
    }
}

總結(jié)來說，盡管兩種方式都可以創(chuàng)建并啟動線程，但在復雜應(yīng)用中，由于其靈活性和設(shè)計原則上的優(yōu)勢，通常推薦優(yōu)先采用實現(xiàn)Runnable接口的方式來定義線程任務(wù)。同時結(jié)合Thread類提供的各種方法，可以更好地控制線程的行為和狀態(tài)。

異步模型與Future接口

異步模型與Future接口

在Java多線程編程中，為了支持執(zhí)行有返回值的任務(wù)并獲取其結(jié)果，JDK引入了Callable接口和Future接口。這兩種接口為開發(fā)者提供了處理異步任務(wù)的強大工具。

Callable接口
Callable接口提供了一個call()方法，它具有返回類型并且可以拋出異常，這使得線程能夠執(zhí)行一個可能需要較長時間且有明確結(jié)果的計算任務(wù)。例如：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CallableExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 創(chuàng)建可緩存線程池
        ExecutorService executor = Executors.newCachedThreadPool();

        // 自定義實現(xiàn)Callable接口的任務(wù)類
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(1000); // 模擬耗時操作
                return 42; // 返回計算結(jié)果
            }
        };

        // 提交任務(wù)到線程池并獲取Future對象
        Future<Integer> futureResult = executor.submit(task);

        // 使用get方法阻塞等待結(jié)果，并打印出來
        System.out.println("Future result: " + futureResult.get());

        // 關(guān)閉線程池
        executor.shutdown();
    }
}

在這個例子中，我們創(chuàng)建了一個實現(xiàn)了Callable接口的匿名內(nèi)部類，該類在call()方法中模擬了一個耗時計算過程，并返回一個整數(shù)值作為結(jié)果。通過ExecutorService提交這個任務(wù)后，得到一個Future對象，然后調(diào)用其get()方法來阻塞等待計算結(jié)果。

Future接口
Future接口代表了一個異步計算的結(jié)果，它提供了幾個關(guān)鍵方法：

• cancel(boolean mayInterruptIfRunning)：試圖取消正在執(zhí)行的任務(wù)，如果mayInterruptIfRunning為true，則會嘗試中斷線程。
• isCancelled()：檢查是否已經(jīng)取消了此任務(wù)。
• isDone()：判斷任務(wù)是否已完成，無論正常結(jié)束還是被取消。
• get() 和 get(long timeout, TimeUnit unit)：阻塞等待直到計算完成或超時，然后獲取計算結(jié)果。如果不希望無限期等待，可以選擇帶有超時參數(shù)的方法。

使用Future接口的一個重要優(yōu)勢在于，它可以讓我們以同步或異步的方式控制任務(wù)的執(zhí)行和結(jié)果的獲取。同時，由于Future提供了取消任務(wù)的能力，因此相比Runnable更適合那些需要隨時中止的任務(wù)場景。

此外，JDK還提供了FutureTask類，它是Future接口和Runnable接口的實現(xiàn)類，既可以作為一個Runnable對象交給Thread或者ExecutorService執(zhí)行，又能持有并管理計算結(jié)果。通過FutureTask，我們可以更方便地進行異步計算以及狀態(tài)跟蹤。

FutureTask類與用途

FutureTask類在Java多線程編程中扮演著關(guān)鍵角色，它是對Runnable接口和Future接口的融合實現(xiàn)。作為一個可運行且具有未來結(jié)果的任務(wù)封裝器，F(xiàn)utureTask可以將任務(wù)提交給線程執(zhí)行，并通過Future接口提供對任務(wù)狀態(tài)、取消操作以及獲取計算結(jié)果的支持。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 創(chuàng)建一個FutureTask實例，使用Callable實現(xiàn)的任務(wù)
        Callable<Integer> callable = () -> {
            Thread.sleep(1000); // 模擬耗時計算
            return 123; // 返回計算結(jié)果
        };

        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        // 將FutureTask作為Runnable對象提交到線程池或直接創(chuàng)建新線程啟動
        Thread thread = new Thread(futureTask);
        thread.start();

        // 當前線程等待FutureTask完成并獲取結(jié)果
        Integer result = futureTask.get();
        System.out.println("FutureTask計算結(jié)果: " + result);
    }
}

在上述示例中，我們首先定義了一個實現(xiàn)了Callable接口的任務(wù)對象，然后通過FutureTask來包裝這個任務(wù)。FutureTask既可以直接傳遞給Thread對象使其成為一個可運行的任務(wù)，也可以提交給ExecutorService進行異步執(zhí)行。當調(diào)用其get()方法時，當前線程會阻塞直到任務(wù)完成，之后返回計算得到的結(jié)果。

FutureTask的主要優(yōu)勢在于它為異步任務(wù)提供了生命周期管理功能，包括：

• 任務(wù)調(diào)度：FutureTask可以被多個線程安全地調(diào)度，確保任務(wù)僅被執(zhí)行一次。
• 任務(wù)狀態(tài)跟蹤：內(nèi)部維護了任務(wù)的狀態(tài)機，可以通過isDone()等方法檢查任務(wù)是否已完成或已被取消。
• 結(jié)果獲取：get()方法允許在任務(wù)完成后獲取計算結(jié)果，支持阻塞等待和超時機制。
• 任務(wù)取消：調(diào)用cancel方法可以嘗試中斷正在執(zhí)行的任務(wù)，或者防止尚未開始的任務(wù)執(zhí)行。

總之，F(xiàn)utureTask是Java并發(fā)框架中的重要組件，它結(jié)合了Runnable和Future的優(yōu)點，使得異步任務(wù)的管理和控制更為靈活便捷，極大地提高了程序設(shè)計的效率和代碼的可讀性。

FutureTask的狀態(tài)變遷

在Java多線程編程中，F(xiàn)utureTask類作為實現(xiàn)RunnableFuture接口的實例，不僅封裝了任務(wù)執(zhí)行邏輯，還負責管理任務(wù)狀態(tài)。FutureTask內(nèi)部維護了一個volatile的int型變量state來表示其生命周期中的不同狀態(tài)。

1. NEW：初始狀態(tài)，表示FutureTask尚未開始執(zhí)行。
2. COMPLETING：瞬態(tài)狀態(tài)，表示任務(wù)正在完成，即call()方法正在運行或者結(jié)果已經(jīng)設(shè)置，等待后續(xù)的完成處理過程。
3. NORMAL：正常結(jié)束狀態(tài)，任務(wù)已成功執(zhí)行并設(shè)置了結(jié)果。
4. EXCEPTIONAL：異常結(jié)束狀態(tài)，任務(wù)在執(zhí)行過程中拋出了未捕獲的異常，結(jié)果被設(shè)置為該異常對象。
5. CANCELLED：取消狀態(tài)，通過調(diào)用cancel方法且成功取消了任務(wù)，此時任務(wù)不會繼續(xù)執(zhí)行。
6. INTERRUPTING：中斷中狀態(tài)，也是瞬態(tài)狀態(tài)，表明正在進行取消操作，并嘗試中斷底層的任務(wù)執(zhí)行線程。
7. INTERRUPTED：已中斷狀態(tài)，意味著任務(wù)在取消過程中已被成功中斷。

這些狀態(tài)之間的轉(zhuǎn)換路徑如下：

• NEW -> COMPLETING -> NORMAL 或 EXCEPTIONAL
• NEW -> CANCELLED
• NEW -> INTERRUPTING -> INTERRUPTED

FutureTask的設(shè)計確保了任務(wù)只執(zhí)行一次，即使在并發(fā)環(huán)境下也能正確地管理狀態(tài)變遷和結(jié)果返回。例如，在高并發(fā)場景下，如果有多個線程同時嘗試啟動一個FutureTask，它會保證僅有一個線程實際執(zhí)行任務(wù)，其余線程等待結(jié)果。

以下是一個簡單的FutureTask狀態(tài)變遷的示例代碼片段，但請注意，由于FutureTask內(nèi)部對狀態(tài)變更做了嚴格控制和同步處理，我們無法直接模擬所有狀態(tài)變遷的過程：

public class FutureTaskStateExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(1000); // 模擬耗時計算
                return 42; // 正常返回結(jié)果
            }
        });

        Thread t = new Thread(futureTask);
        t.start();

        // 在任務(wù)執(zhí)行期間嘗試取消
        futureTask.cancel(true);

        // 判斷任務(wù)是否已取消或已完成
        if (futureTask.isCancelled()) {
            System.out.println("任務(wù)已取消");
        } else if (futureTask.isDone()) {
            System.out.println("任務(wù)已完成，結(jié)果：" + futureTask.get());
        }

        // 根據(jù)實際情況，這里可能輸出"任務(wù)已取消"或"任務(wù)已完成"
    }
}

這段代碼創(chuàng)建了一個FutureTask實例并在新線程中執(zhí)行。在任務(wù)執(zhí)行過程中嘗試取消，根據(jù)最終狀態(tài)判斷任務(wù)是已取消還是已完成。真實情況下，F(xiàn)utureTask會確保按照預定義的狀態(tài)變遷規(guī)則進行切換。

總結(jié)

Java多線程編程提供了豐富的類與接口，便于開發(fā)者高效地創(chuàng)建、管理和控制線程。在實際應(yīng)用中，我們可以通過以下幾種方式來實現(xiàn)：

• 繼承Thread類或?qū)崿F(xiàn)Runnable接口：前者通過重寫run()方法定義線程任務(wù)；后者更符合面向?qū)ο笤瓌t且不受單繼承限制，允許通過構(gòu)造函數(shù)傳遞Runnable實例給Thread類以啟動新線程。示例代碼展示了如何通過這兩種途徑創(chuàng)建并運行線程。

// 繼承Thread類
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }

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

// 實現(xiàn)Runnable接口
public class RunnableTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable Task running");
    }

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

• 使用Future和Callable進行異步計算：當需要獲取線程執(zhí)行結(jié)果時，可以結(jié)合Callable和Future接口實現(xiàn)異步模型。FutureTask作為這兩個接口的實現(xiàn)，兼顧了任務(wù)執(zhí)行和結(jié)果返回的功能。例如：

import java.util.concurrent.*;

public class FutureTaskExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = () -> { return calculate(); };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        Thread executor = new Thread(futureTask);
        executor.start();

        Integer result = futureTask.get(); // 阻塞等待結(jié)果
        System.out.println("FutureTask returned: " + result);
    }

    private static Integer calculate() {
        try {
            Thread.sleep(1000);
            return 42;
        } catch (InterruptedException e) {
            return -1;
        }
    }
}

• FutureTask狀態(tài)變遷：FutureTask內(nèi)部維護了多種狀態(tài)，如NEW、COMPLETING、NORMAL等，用于準確反映任務(wù)從初始化到完成或取消的全過程，確保并發(fā)環(huán)境下的正確性。

綜上所述，在Java多線程編程中，通過靈活運用Thread、Runnable、Callable以及Future/FutureTask等工具，開發(fā)者能夠更好地設(shè)計和管理復雜的并發(fā)場景，并利用異步編程提高系統(tǒng)性能與響應(yīng)速度。深入理解這些類與接口的工作機制及應(yīng)用場景，是構(gòu)建高效穩(wěn)定多線程應(yīng)用程序的關(guān)鍵所在。同時，學習線程組、線程優(yōu)先級等相關(guān)概念，將有助于進一步提升對Java多線程編程的全面掌控能力。