Java 中创建线程的方式究竟有哪些？(java中创建线程的方式有哪几种)

在 Java 编程中，创建线程是一个非常重要的概念。线程是程序中的执行单元，它可以独立地执行代码，从而实现并发执行的效果。在 Java 中，有多种方式可以创建线程，以下是几种常见的方式：

一、继承 Thread 类

这是最基本的创建线程的方式。通过继承 Thread 类，并重写其 run() 方法，在 run() 方法中编写线程要执行的代码。然后通过创建线程对象并调用 start() 方法来启动线程。以下是一个简单的示例：

class MyThread extends Thread {
    public void run() {
        // 线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

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

在上述代码中，我们定义了一个 MyThread 类，继承自 Thread 类。在 MyThread 类的 run() 方法中，打印了 100 次线程的编号。在 main() 方法中，创建了 MyThread 对象，并调用 start() 方法启动线程。

二、实现 Runnable 接口

除了继承 Thread 类，还可以实现 Runnable 接口来创建线程。Runnable 接口只定义了一个 run() 方法，需要我们自己实现该方法来编写线程的执行逻辑。然后通过创建 Thread 对象，并将实现了 Runnable 接口的对象作为参数传递给 Thread 的构造函数，最后调用 start() 方法启动线程。以下是示例代码：

class MyRunnable implements Runnable {
    public void run() {
        // 线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

在上述代码中，我们定义了一个 MyRunnable 类，实现了 Runnable 接口。在 run() 方法中，打印了 100 次线程的编号。在 main() 方法中，创建了 MyRunnable 对象，并将其作为参数传递给 Thread 的构造函数，创建了 Thread 对象，最后调用 start() 方法启动线程。

三、使用 Lambda 表达式

在 Java 8 及以上版本中，可以使用 Lambda 表达式来创建线程。Lambda 表达式可以使代码更加简洁和易读。以下是使用 Lambda 表达式创建线程的示例：

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

public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 使用 Lambda 表达式创建线程并提交到线程池
        executor.execute(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread: " + i);
            }
        });

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

在上述代码中，我们使用 Executors.newFixedThreadPool(10) 创建了一个固定大小为 10 的线程池。然后使用 executor.execute() 方法提交一个 Lambda 表达式创建的线程任务到线程池。Lambda 表达式中的代码实现了线程的执行逻辑，即打印 100 次线程的编号。最后调用 executor.shutdown() 方法关闭线程池。

四、使用 Callable 和 Future 创建线程

Callable 接口与 Runnable 接口类似，也定义了一个 call() 方法，但是 call() 方法有返回值。可以通过 FutureTask 类来包装 Callable 对象，然后将 FutureTask 对象作为参数传递给 Thread 的构造函数来创建线程。以下是示例代码：

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 {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(1);

        // 创建 Callable 对象
        MyCallable callable = new MyCallable();

        // 使用 FutureTask 包装 Callable 对象
        Future<Integer> future = executor.submit(callable);

        try {
            // 获取 Callable 的返回值
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

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

在上述代码中，我们定义了一个 MyCallable 类，实现了 Callable 接口。在 call() 方法中，计算了 0 到 99 的累加和。在 main() 方法中，创建了一个固定大小为 1 的线程池，创建了 MyCallable 对象，并使用 FutureTask 包装 Callable 对象。然后将 FutureTask 对象作为参数传递给 executor.submit() 方法提交到线程池。在获取 Callable 的返回值时，使用 future.get() 方法阻塞等待线程执行完成并获取结果。最后关闭线程池。

总结：

以上就是 Java 中创建线程的几种常见方式，每种方式都有其特点和适用场景。继承 Thread 类的方式简单直观，但如果需要多个线程共享资源，可能会导致线程安全问题；实现 Runnable 接口的方式更加灵活，可以避免单继承的限制，并且多个线程可以共享同一个 Runnable 对象；使用 Lambda 表达式的方式简洁易懂，适用于简单的线程任务；使用 Callable 和 Future 创建线程的方式可以获取线程的返回值，适用于需要返回结果的情况。在实际开发中，可以根据具体的需求选择合适的创建线程的方式。