Java多线程向线程传递数据的三种方法

一、通过构造方法传递数据

这是最基础且安全的数据传递方式。在创建 Thread 类的子类实例时，我们可以在调用 start() 方法之前，通过构造函数将所需的参数传入。随后，将这些参数保存为类的私有成员变量（Field），以便在线程运行的 run() 方法中直接读取和使用。

实现步骤：

1. 定义线程类：继承 Thread 或实现 Runnable 接口，并声明必要的私有变量。
2. 编写构造函数：接收外部传入的参数，并将其赋值给对应的类成员变量。
3. 在 run 方法中调用：run() 执行时即可直接访问已保存的成员变量。

package mythread;
public class MyThread1 extends Thread {
    private String name;
    // 1. 通过构造方法传入数据
    public MyThread1(String name) {
        this.name = name;
    }
    public void run() {
        // 2. 在run方法中使用保存的数据
        System.out.println("hello " + name);
    }
    public static void main(String[] args) {
        // 3. 创建对象时直接传入数据
        Thread thread = new MyThread1("world");
        thread.start();
    }
}

优势与局限： 这种方式确保了在线程启动前数据已经就位，避免了线程运行后数据才到达的竞争问题。但如果需要传递的参数过多，会导致构造函数变得臃肿；此外，如果需要提供类似默认参数的效果，则需要频繁使用构造器重载，增加了代码维护成本。

二、通过成员变量和方法传递数据

除了构造函数，创建对象后通过对象的公共 setter 方法或暴露字段来设置数据是另一种常见做法。这种方式提供了更大的灵活性，允许在创建对象之后、启动线程之前修改或补充数据。

package mythread;
public class MyThread2 implements Runnable {
    private String name;
    // 1. 定义 Setter 方法
    public void setName(String name) {
        this.name = name;
    }
    public void run() {
        System.out.println("hello " + name);
    }
    public static void main(String[] args) {
        // 2. 先创建对象
        MyThread2 myThread = new MyThread2();
        // 3. 再通过方法设置参数
        myThread.setName("world");
        // 4. 启动线程
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

该方法适用于参数较多、部分参数可能在对象创建后才确定的场景。但需要注意的是，如果多个线程同时访问该成员变量，需确保线程安全性，例如在赋值阶段不使用其他线程共享该对象。

三、通过回调函数（Callback）传递数据

前两种方法属于“主动注入”，即主程序负责将数据传给线程。而在某些复杂业务逻辑中，线程在运行过程中需要根据产生的中间结果（如实时生成的随机数）去调用外部逻辑进行处理。此时，可以通过回调函数机制实现数据的双向或动态交互。

package mythread;
import java.util.Random;

// 用于存储处理结果的容器
class Data {
    public int value = 0;
}

// 包含具体处理逻辑的工作类
class Work {
    public void process(Data data, Integer... numbers) {
        for (int n : numbers) {
            data.value += n;
        }
    }
}

public class MyThread3 extends Thread {
    private Work work;
    public MyThread3(Work work) {
        this.work = work;
    }
    public void run() {
        Random random = new Random();
        Data data = new Data();
        // 线程内部产生动态数据
        int n1 = random.nextInt(1000);
        int n2 = random.nextInt(2000);
        int n3 = random.nextInt(3000);
        
        // 触发回调：将线程内的数据交给外部 Work 处理
        work.process(data, n1, n2, n3);
        
        System.out.println(n1 + "+" + n2 + "+" + n3 + "=" + data.value);
    }
    public static void main(String[] args) {
        Thread thread = new MyThread3(new Work());
        thread.start();
    }
}

原理解析： 在上面的示例中，process 方法即为回调函数。本质上，它是线程运行期间主动引发的一次“事件”。这种机制常用于解耦，当线程内部产生的数据需要被外部的处理器消费时，线程只需调用传入的接口或对象的方法，而不必关心外部具体的处理逻辑。这类似于 Windows API 中的回调机制，实现了数据在不同模块间的动态流动。

以上就是Java多线程向线程传递数据的详细方法与示例，更多关于Java并发编程的资料请关注本站其它相关文章！