Java进阶篇之多线程

最新推荐文章于 2025-08-25 20:07:33 发布

原创最新推荐文章于 2025-08-25 20:07:33 发布 · 905 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java

Java进阶

引言 🚀

在前面的文章中，我们介绍了NIO（Java进阶篇之NIO基础）。你是不是曾经在面对需要处理大量任务的应用时，感觉单线程根本不够用？😓 如果你想让你的应用运行得更快、更高效，多线程是你不可避免的选择！通过多线程，你可以让计算机同时处理多个任务，从而实现并行处理和高效资源利用。今天，我就带你一起深入了解 Java 中的多线程，看看如何巧妙地利用它来提升你应用的性能和响应速度💨。

让我们开始这个充满挑战与趣味的多线程之旅吧！🎢

1️⃣ 使用 ExecutorService 创建线程池

一、多线程基础 🧠

多线程是指在同一个程序中，同时执行多个线程，每个线程有自己的执行路径。每个线程有自己的栈和程序计数器，而所有线程共享堆内存中的数据。

多线程的优势：

提高程序的执行效率 🏎️
利用多核处理器资源 ⚙️
提升程序的响应性 💬

1️⃣ 线程的生命周期 ⏳

线程在 Java 中有一个明确的生命周期，它从创建到销毁经历了多个状态。我们可以用以下图示来简化理解👇：

新建：线程对象已经创建，但尚未调用start()方法。
可运行：调用start()后，线程进入可运行状态，等待 CPU 分配时间片。
运行中：线程正在执行其run()方法。
阻塞：线程因等待某些条件或资源变得不可执行。
死亡：线程执行完毕或被强制终止。

二、Java中的多线程实现方式 💡

Java 提供了两种创建多线程的方式：继承 Thread 类和实现 Runnable 接口。我们来对比一下这两种方式的异同 🧐。

方式	继承 `Thread` 类 💪	实现 `Runnable` 接口 🏃
灵活性	低，不能继承其他类	高，可以继承其他类
线程数量	每次只能继承一个线程类	可以创建多个线程实例
推荐使用	不常用，适合简单场景	推荐，适用于复杂任务

1️⃣ 继承 `Thread` 类 👑

最简单的方式是直接继承 Thread 类并重写其 run() 方法。

示例代码：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread " + Thread.currentThread().getId() + " is running!");
    }
}

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

在这个例子中，MyThread 继承了 Thread 类并重写了 run() 方法。通过调用 start() 方法，线程开始运行。

2️⃣ 实现 `Runnable` 接口 🏃

通过实现 Runnable 接口，我们可以更灵活地创建线程，并且还可以将多个线程共享同一个 Runnable 实例。

示例代码：

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

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

通过这种方式，线程的创建变得更加灵活，多个线程可以共享同一个 Runnable 实例，适用于多任务并发执行。

三、线程同步 🔒

在多线程环境中，经常会遇到多个线程访问共享资源的问题。如果没有适当的同步机制，可能会导致数据不一致或者程序崩溃。💥

Java 提供了几种常见的同步机制：

同步方法
同步代码块
Lock 接口

1️⃣ 同步方法 🏅

通过在方法声明上加 synchronized 关键字，可以让多个线程同步地访问该方法。

示例代码：

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // 创建多个线程进行并发执行
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) counter.increment();
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

通过 synchronized 关键字，保证了 increment() 和 getCount() 方法的线程安全性，即使多个线程同时访问这些方法，也不会出现数据竞争问题。

2️⃣ 同步代码块 🛠️

同步方法虽然简单，但有时效率不高。我们可以将方法中的代码块进行同步，减少锁的持有时间。

示例代码：

class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

通过同步代码块，我们可以让多个线程同时访问非同步代码块，从而提高性能。

四、线程池 🛠️⚡

创建和销毁线程的开销是巨大的，尤其在高并发场景下。为了提高效率，Java 提供了线程池机制。线程池维护了一组预先创建好的线程，任务提交到线程池后由线程池中的空闲线程来执行。

1️⃣ 使用 `ExecutorService` 创建线程池

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executorService.submit(() -> {
                System.out.println("Thread " + Thread.currentThread().getId() + " is executing task");
            });
        }

        executorService.shutdown();
    }
}

在这个例子中，我们创建了一个包含 3 个线程的线程池，并提交了 5 个任务。线程池中的线程会并发执行这些任务。