java实现多线程的方法有哪些

// 方法一：继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

// 方法二：实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();  // 启动线程
    }
}

// 方法三：使用Executor框架（推荐）
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Runnable task1 = () -> System.out.println("Task 1 is running.");
        Runnable task2 = () -> System.out.println("Task 2 is running.");

        executor.execute(task1);
        executor.execute(task2);

        executor.shutdown();  // 关闭线程池
    }
}

// 方法四：使用Callable和Future（支持返回值）
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        return 123;  // 返回一个整数
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        MyCallable callable = new MyCallable();
        Future<Integer> future = executor.submit(callable);

        try {
            Integer result = future.get();  // 获取返回值
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();  // 关闭线程池
        }
    }
}

以上代码展示了Java中实现多线程的四种常见方法：

1. 继承Thread类：通过创建一个继承自Thread类的子类，并重写run方法来定义线程的任务。然后通过调用start方法启动线程。
2. 实现Runnable接口：通过实现Runnable接口并重写run方法，将任务逻辑封装在其中。接着创建一个Thread对象并将Runnable实例传递给它，再调用start方法启动线程。
3. 使用Executor框架：通过ExecutorService来管理线程池和任务调度。这是推荐的方式，因为它可以更方便地管理和复用线程资源。
4. 使用Callable和Future：与Runnable类似，但Callable接口允许任务有返回值，并且可以通过Future对象获取任务执行的结果。