线程常用的几种使用方式?

在 Java 中，线程可以通过几种不同的方式进行创建和使用。以下是常用的几种方式：

1. 继承 Thread 类

这种方式通过创建一个子类，继承自 Thread 类，并重写其 run() 方法来定义线程的行为。

示例代码：

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

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

2. 实现 Runnable 接口

创建一个类实现 Runnable 接口，并实现 run() 方法，然后通过 Thread 类来启动线程。这种方式更灵活，因为 Java 不支持多重继承。

示例代码：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的任务
        System.out.println("Thread is running.");
    }
}

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

3. 使用 Lambda 表达式（Java 8 及以上）

在 Java 8 及以上版本中，如果实现 Runnable 接口的 run() 方法只包含一行代码，可以使用 Lambda 表达式来简化代码。

示例代码：

public class LambdaExample {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Thread is running.");
        Thread thread = new Thread(runnable);
        thread.start(); // 启动线程
    }
}

4. 使用 Executor 框架

Executor 框架是 Java 5 引入的，用于管理线程池和并发任务的更高级抽象。它通过 Executor 接口及其实现来管理线程。

示例代码：

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

public class ExecutorExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        executor.execute(() -> System.out.println("Task 1 is running."));
        executor.execute(() -> System.out.println("Task 2 is running."));
        
        executor.shutdown(); // 确保所有任务完成并关闭线程池
    }
}

5. 使用 Future 和 Callable

Callable 接口与 Runnable 类似，但可以返回值，并在执行时可以抛出异常。结合 ExecutorService 使用，可以更灵活地处理并发任务。

示例代码：

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;

public class CallableExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        Future<Integer> future = executor.submit((Callable<Integer>) () -> {
            // 线程要执行的任务
            return 42;
        });

        try {
            System.out.println("Result: " + future.get()); // 获取结果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

总结

Java 中创建和管理线程的方式多种多样，从简单的继承自 Thread 类到使用现代的 Executor 框架，各有优势和适用场景。根据实际需求选择合适的方法，可以有效提高代码的可读性和管理性。如果你有其它问题或需要更详细的解释，请随时在评论区留言探讨！