能否在run方法中让不同线程调用不同方法？多线程并行执行指定方法可行吗？

当然可行！你的核心需求是让不同方法跑在独立线程上并行执行，而不是像现在这样把所有方法塞进同一个run()里串行跑，我给你几个常用的实现思路：

方案1：直接创建独立Thread实例绑定对应方法 #

这是最直观的方式，给每个需要并行执行的方法单独创建线程，明确指定线程名称和要执行的逻辑：

// 先定义包含目标方法的类
public class TaskHandler {
    public void method1() {
        // 这里写method1的业务逻辑
        System.out.println("method1 运行在线程：" + Thread.currentThread().getName());
    }

    public void method2() {
        // 这里写method2的业务逻辑
        System.out.println("method2 运行在线程：" + Thread.currentThread().getName());
    }

    public void method3() {
        // 这里写method3的业务逻辑
        System.out.println("method3 运行在线程：" + Thread.currentThread().getName());
    }
}

// 启动线程的入口代码
public class Main {
    public static void main(String[] args) {
        TaskHandler handler = new TaskHandler();

        // 让threadONE执行method1
        Thread threadONE = new Thread(handler::method1, "threadONE");
        // 让threadTWO执行method2
        Thread threadTWO = new Thread(handler::method2, "threadTWO");
        // 如果method3也需要并行，同理创建threadTHREE即可

        // 启动线程，它们会立即进入并行执行状态
        threadONE.start();
        threadTWO.start();
    }
}

这种方式的好处是逻辑清晰，每个线程的职责明确，启动后threadONE和threadTWO会各自独立执行对应方法，完全并行。

方案2：使用线程池管理（适合多任务/线程复用场景） #

如果后续你有更多方法需要并行执行，或者希望复用线程减少创建开销，用ExecutorService线程池会更高效：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        // 自定义线程工厂，给线程命名（方便调试）
        ThreadFactory threadFactory = (Runnable r) -> {
            AtomicInteger threadNum = new AtomicInteger(1);
            Thread thread = new Thread(r);
            thread.setName("thread-" + threadNum.getAndIncrement());
            return thread;
        };

        // 创建固定大小的线程池（这里设为2，对应你的两个方法）
        ExecutorService executor = Executors.newFixedThreadPool(2, threadFactory);
        TaskHandler handler = new TaskHandler();

        // 提交method1和method2到线程池，会自动分配线程执行
        executor.submit(handler::method1);
        executor.submit(handler::method2);

        // 所有任务提交完成后，关闭线程池（避免资源泄漏）
        executor.shutdown();
    }
}

线程池会帮你管理线程的创建、复用和销毁，适合需要频繁启动并行任务的场景。

关于“在run方法内部让不同线程调用不同方法”的补充 #

如果你一定要在某个线程的run()方法内部启动其他线程来执行不同方法，也是可以的——此时原来的线程相当于一个“线程启动器”，示例如下：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 在当前线程的run方法里，启动threadONE执行method1
        new Thread(this::method1, "threadONE").start();
        // 启动threadTWO执行method2
        new Thread(this::method2, "threadTWO").start();
        
        // 如果method3需要在当前线程执行，直接调用即可；如果也需要并行，同样启动新线程
        method3();
    }

    private void method1() { /* 业务逻辑 */ }
    private void method2() { /* 业务逻辑 */ }
    private void method3() { /* 业务逻辑 */ }
}

不过要注意：这种方式下，当前线程会在启动完子线程后继续执行后续代码（比如上面的method3()），如果需要等待子线程完成，要调用join()方法，避免主线程提前退出导致子线程被终止。

内容的提问来源于stack exchange，提问作者Mahalingam Chinnasamy