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 接口本身的特性。