[java][代码]Java中创建多线程方法

 在Java中，创建多线程有多种方法。以下是一些常见的方法：

1. 继承 Thread 类
通过继承 Thread 类并重写其 run 方法来创建线程。


class MyThread extends Thread {
    public void run() {
        // 线程要执行的任务
        System.out.println("线程运行中...");
    }
}

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

2. 实现 Runnable 接口
通过实现 Runnable 接口并实现其 run 方法，然后将 Runnable 实现类传递给 Thread 对象。

class MyRunnable implements Runnable {
    public void run() {
        // 线程要执行的任务
        System.out.println("线程运行中...");
    }
}

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

3. 使用 ExecutorService 接口
Java提供了 java.util.concurrent 包，其中 ExecutorService 接口是创建线程池和管理线程的高级工具。

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

class MyRunnable implements Runnable {
    public void run() {
        // 线程要执行的任务
        System.out.println("线程运行中...");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
        executor.execute(new MyRunnable()); // 提交任务给线程池
        executor.shutdown(); // 关闭线程池
    }
}

4. 使用 Callable 和 Future
Callable 接口与 Runnable 类似，但它可以返回一个结果并且能抛出异常。通过 Future 接口可以获取 Callable 任务的结果。

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

class MyCallable implements Callable<String> {
    public String call() throws Exception {
        // 线程要执行的任务
        return "线程运行结果";
    }
}

public class ThreadExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get()); // 获取任务结果
        executor.shutdown();
    }
}

5. 匿名内部类
在实际开发中，经常使用匿名内部类来创建线程，这样可以减少代码量。

public class ThreadExample {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            public void run() {
                System.out.println("线程运行中...");
            }
        }).start();
    }
}

6. Lambda 表达式（Java 8+）
Java 8 引入了 Lambda 表达式，使得创建线程更加简洁。

public class ThreadExample {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("线程运行中...")).start();
    }
}


每种方法都有其适用场景，你可以根据具体需求选择合适的方法来创建和管理线程。