Java中怎么获取子线程方法、结果或状态

SmileNicky

发布于 2025-10-24 08:18:50

9900

文章被收录于专栏：Nicky's blogNicky's blog

运行总次数：0

在Java中，获取子线程的方法或与子线程交互，通常可以通过自定义线程类、使用共享变量或回调接口等方式实现。以下是几种常见方式：

1. 自定义线程类（继承Thread）

通过继承Thread类，将需要暴露的方法定义为成员方法，主线程可以通过线程对象直接调用。

public class CustomThread extends Thread {
    private int count = 0;
    
    @Override
    public void run() {
        // 子线程执行的任务
        for (int i = 0; i < 5; i++) {
            count++;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    // 子线程的自定义方法（供外部调用）
    public int getCount() {
        return count;
    }
    
    public static void main(String[] args) throws InterruptedException {
        CustomThread thread = new CustomThread();
        thread.start();
        
        // 主线程等待一段时间后获取子线程的状态
        Thread.sleep(1000);
        System.out.println("子线程当前计数: " + thread.getCount()); // 可能输出2
        
        thread.join(); // 等待子线程结束
        System.out.println("子线程最终计数: " + thread.getCount()); // 输出5
    }
}

2. 使用Runnable与共享对象

通过实现Runnable接口，将共享数据和方法封装在一个对象中，主线程和子线程通过该对象交互。

public class ShareData {
    private int result;
    
    public void setResult(int value) {
        this.result = value;
    }
    
    public int getResult() {
        return result;
    }
}

public class MyRunnable implements Runnable {
    private ShareData shareData;
    
    public MyRunnable(ShareData data) {
        this.shareData = data;
    }
    
    @Override
    public void run() {
        // 子线程计算并设置结果
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }
        shareData.setResult(sum);
    }
    
    public static void main(String[] args) throws InterruptedException {
        ShareData data = new ShareData();
        Thread thread = new Thread(new MyRunnable(data));
        thread.start();
        
        thread.join(); // 等待子线程完成
        System.out.println("子线程计算结果: " + data.getResult()); // 输出55
    }
}

3. 使用Callable与Future（获取返回值）

如果需要获取子线程的执行结果，推荐使用Callable和Future，这是Java并发包中专门用于处理带返回值线程的方式。

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

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 子线程执行任务并返回结果
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            Thread.sleep(300);
        }
        return sum;
    }
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 创建Callable任务
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        
        // 启动线程
        new Thread(futureTask).start();
        
        // 主线程获取子线程返回值（会阻塞直到结果返回）
        System.out.println("等待子线程结果...");
        int result = futureTask.get(); // get()方法会阻塞
        System.out.println("子线程返回结果: " + result); // 输出15
    }
}

4. 使用线程池管理（更高效）

在实际开发中，通常使用线程池来管理线程，结合Future获取子线程结果：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolExample {
    public static void main(String[] args) throws Exception {
        // 创建线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        // 提交任务并获取Future对象
        Future<Integer> future = executor.submit(() -> {
            // 子线程任务
            Thread.sleep(1000);
            return 100; // 返回结果
        });
        
        System.out.println("任务执行中...");
        int result = future.get(); // 获取结果
        System.out.println("子线程返回值: " + result); // 输出100
        
        // 关闭线程池
        executor.shutdown();
    }
}