线程方法接收参数和返回参数,Java的两种线程实现方式对比

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

热门相关:如果能少爱你一点   豪门情变,渣总裁滚远点!   买妻种田:山野夫君,强势宠!   未来兽世:买来的媳妇,不生崽   本法官萌萌哒