java 如何创建线程

创建线程的方法

在 Java 中，创建线程主要有以下两种方式：

继承 Thread 类

通过继承 Thread 类并重写 run() 方法，可以创建一个新的线程。

class MyThread extends Thread {
    @Override
    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 接口

由于 Java 不支持多重继承，更推荐通过实现 Runnable 接口来创建线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}

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

使用 Lambda 表达式简化

Java 8 以后，可以通过 Lambda 表达式简化 Runnable 接口的实现。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running.");
        });
        thread.start();
    }
}

使用 Callable 和 Future

如果需要线程返回结果，可以使用 Callable 接口配合 Future 或 FutureTask。

import java.util.concurrent.*;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Thread execution completed.";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get()); // 获取线程返回结果
        executor.shutdown();
    }
}

使用线程池

为了提高性能，推荐使用线程池管理线程。

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

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        executor.execute(() -> {
            System.out.println("Thread is running.");
        });
        executor.shutdown();
    }
}

每种方法适用于不同场景，选择合适的方式可以提高代码的可维护性和性能。