【多线程奇妙屋】 Java 的 Thread类必会小技巧，教你如何用多种方式快速创建线程，学并发编程必备(实践篇)

在 Java 中，多线程编程是一个重要的概念，它可以有效地利用系统资源，提高程序的执行效率。Java 提供了丰富的 API 来支持多线程编程，其中最常用的是 Thread 类。本文将介绍几种快速创建线程的方法，通过代码示例帮助大家更好地理解和实践并发编程。

方法一：继承 Thread 类

直接继承 Thread 类是一种常见的方法。在这个方法中，我们需要创建一个新的类并继承 Thread，重写它的 run() 方法。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
        for (int i = 0; i < 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2
    }
}

方法二：实现 Runnable 接口

另一种方式是实现 Runnable 接口，优点是可以实现多重继承。在这种方法中，我们需要实现 run() 方法并通过 Thread 类来启动线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running.");
        for (int i = 0; i < 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);

        thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2
    }
}

方法三：使用 Lambda 表达式（Java 8 及以上）

在 Java 8 及以上版本中，我们可以使用 Lambda 表达式来更简洁地创建线程。当需要实现 Runnable 接口的唯一方法时，Lambda 表达式显得非常方便。

public class LambdaExample {
    public static void main(String[] args) {
        Runnable runnable = () -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            for (int i = 0; i < 5; i++) {
                System.out.println("Count: " + i);
            }
        };

        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2
    }
}

方法四：使用 Executors 框架

Java 提供了 Executors 框架，使得线程的管理更加高效。通过线程池，我们可以避免频繁地创建和销毁线程，从而提高应用程序的性能。

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

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池

        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is running.");
            for (int i = 0; i < 5; i++) {
                System.out.println("Count: " + i);
            }
        };

        executorService.submit(task); // 提交任务
        executorService.submit(task); // 提交任务

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

结论

在 Java 中，我们可以采用多种方式创建线程，每种方式都有其特定的适用场景。通过继承 Thread 类、实现 Runnable 接口、使用 Lambda 表达式和 Executors 框架，我们可以创建和管理复杂的多线程应用程序。在实际开发中，了解并灵活运用这些技术将大大提高我们的工作效率和代码质量。掌握这些小技巧，是学习 Java 并发编程的必要步骤。希望本文能为你提供一些帮助，让你在多线程编程的道路上更加顺利。