The difference beteen two way

總所周知，Java實現多線程有兩種方式，分別是繼承Thread類和實現Runable介面，那麼它們的區別是什麼？

繼承 Thread 類：
通過繼承 Thread 類，你可以創建一個直接表示線程的類。你可以覆蓋 Thread 類中的 run 方法來定義線程的邏輯。當調用 start 方法啟動線程時，會執行該類中的 run 方法。
優點：簡單直觀，可以直接訪問線程的方法和屬性。
缺點：由於 Java 不支持多重繼承，因此如果你的類已經繼承了其他類，就無法再繼承 Thread 類。此外，由於繼承是一種靜態的方式，它限制了類的擴展性。

實現 Runnable 介面：
通過實現 Runnable 介面，你可以將線程的邏輯封裝在一個獨立的類中。這個類只需要實現 Runnable 介面中的 run 方法。然後，你可以將該類的實例傳遞給 Thread 對象，並調用 start 方法啟動線程。
優點：避免了單繼承的限制，提高了代碼的靈活性和可維護性。可以在多個類中共用同一個線程對象。
缺點：在訪問線程的方法和屬性時需要通過 Thread 對象來間接訪問。

總結：
還是實現 Runnable 比較好，代碼比較靈活，避免了單繼承的局限性，最重要的是可以在多個類中共用線程對象。

Method receiving parameters within a thread

Defind a Sub Thread

public class MyRunnable implements Runnable {
    private String parameter;

    public MyRunnable(String parameter) {
        this.parameter = parameter;
    }

    @Override
    public void run() {
        // 在這裡編寫子線程的邏輯，可以使用參數 parameter
        System.out.println("子線程執行，參數為：" + parameter);
    }
}

Main Thread to call Sub Thread

// 在主線程中創建並啟動子線程
public class MainThread {
    public static void main(String[] args) {
        String parameter = "Hello, World!";
        Thread thread = new Thread(new MyRunnable(parameter));
        thread.start();

        // 主線程繼續執行其他操作
        System.out.println("主線程繼續執行");
    }
}

在上面的示例中，我們定義了一個實現了 Runnable 介面的類 MyRunnable。該類的構造函數接收一個參數，並將其保存在成員變數 parameter 中。在 run 方法中，我們可以使用該參數執行子線程的邏輯。

然後，在主線程中，我們創建了一個子線程，並將 MyRunnable 對象作為參數傳遞給 Thread 構造函數。通過調用 start 方法來啟動子線程。

Method return parameters within a thread

在 Java 中，Runnable 介面本身並不支持直接返回值。它的 run 方法沒有定義返回值。然而，你可以通過get方式來實現在 Runnable 實例中獲取返回值的效果。

下麵是一個示例，展示瞭如何通過自定義類來實現在 Runnable 介面中獲取返回值的功能：

public class MyRunnable implements Runnable {
    private int result;

    public int getResult() {
        return result;
    }

    @Override
    public void run() {
        // 執行耗時操作，計算結果
        result = performCalculation();
    }

    private int performCalculation() {
        // 在這裡執行具體的計算邏輯
        // ...
        return 42; // 假設計算結果為 42
    }
}

main

public class MainThread {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();

        // 等待子線程執行完成
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 獲取子線程的返回值
        int result = runnable.getResult();
        System.out.println("子線程的返回值為: " + result);
    }
}

在上述示例中，MyRunnable 類實現了 Runnable 介面，併在其內部定義了一個 result 變數用於保存計算結果。在 run 方法中，你可以執行耗時的計算操作，並將結果賦值給 result 變數。

在主線程中，我們創建了一個 MyRunnable 實例，並將其傳遞給 Thread 構造函數。通過調用 start 方法啟動線程後，我們使用 join 方法等待子線程執行完成。

最後，我們通過調用 getResult 方法獲取子線程的計算結果，並列印輸出。

請註意，這種方式是通過自定義類來實現從子線程中獲取返回值的效果，並不是直接使用 Runnable 介面本身的特性。