Java 语言自发布以来，一直以其强大的多线程处理能力为开发者所熟知。线程是一种轻量级的进程，对于实现并发操作至关重要。在这篇博客中，我们将探讨 Java 中的线程基础概念、线程的创建与管理、同步机制以及线程池的使用。

一、什么是线程

线程是 Java 中最小的执行单元，它是程序中的一个独立路径。Java 提供了对多线程编程的强大支持，使得开发者可以更加高效地利用多核处理器的能力。

线程 vs 进程

  • 进程是一个独立运行的程序，它拥有自己的内存空间。
  • 线程则是进程内的一个子任务，各线程共享进程的内存空间。

二、Java 中线程的创建

Java 提供了两种主要方式来创建线程：

1. 继承 Thread 类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello from MyThread!");
    }
}

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

2. 实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello from MyRunnable!");
    }
}

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

哪种方式更好？

实现 Runnable 接口通常被认为是更好的实践，因为 Java 是单继承的，通过实现接口能带来更高的灵活性。

三、线程同步与通信

在多线程环境中，多个线程可能会同时访问和修改共享资源，这会导致数据不一致的问题。为了防止这种情况，Java 提供了多种同步机制。

1. 同步方法和同步块

  • 同步方法使用 synchronized 关键字来修饰方法。
  • 同步块可以仅对需要同步的代码部分进行加锁。
public class Counter {
    private int count = 0;

    // 同步方法
    public synchronized void increment() {
        count++;
    }

    // 同步块
    public void decrement() {
        synchronized(this) {
            count--;
        }
    }
}

2. 等待与通知

Java 提供了 wait(), notify(), 和 notifyAll() 方法用于线程间的通信。

public class WaitNotifyExample {
    private static final Object LOCK = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread waitingThread = new Thread(() -> {
            synchronized (LOCK) {
                try {
                    System.out.println("Thread is waiting...");
                    LOCK.wait();
                    System.out.println("Thread resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (LOCK) {
                System.out.println("Thread is notifying...");
                LOCK.notify();
            }
        });

        waitingThread.start();
        Thread.sleep(1000); // 确保等待线程先运行
        notifyingThread.start();
    }
}

四、线程池

创建线程是一个开销较大的操作，为了更高效地管理线程，Java 引入了线程池的概念。使用线程池可以重用线程，减少创建和销毁线程的开销。

Java 提供了 Executors 工具类来创建线程池。

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

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

        for (int i = 0; i < 100; i++) {
            executorService.execute(() -> {
                System.out.println("Executing task by " + Thread.currentThread().getName());
            });
        }

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

五、结论

Java 的线程机制为开发者提供了强大的工具来实现并发编程。通过理解线程的基础知识、同步机制和线程池的使用，开发者可以编写出高效且安全的多线程应用程序。希望这篇博客能够帮助你更好地掌握 Java 线程，为你的应用程序性能提升提供支持。