Java 多线程

Java 多线程编程允许程序同时执行多个任务，充分利用多核处理器的性能。Java 提供了丰富的多线程 API 和工具类。

创建线程

1. 继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();

2. 实现 Runnable 接口（推荐）

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

3. 使用 Lambda 表达式

Thread thread = new Thread(() -> {
    System.out.println("线程运行中");
});
thread.start();

线程状态

Java 线程有以下几种状态：

• NEW：新建状态，线程对象已创建但未启动
• RUNNABLE：可运行状态，线程正在 JVM 中执行
• BLOCKED：阻塞状态，等待监视器锁
• WAITING：等待状态，无限期等待
• TIMED_WAITING：定时等待状态，等待指定时间
• TERMINATED：终止状态，线程执行完毕

线程同步

synchronized 关键字

public class Counter {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

Lock 接口

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

线程通信

wait() 和 notify()

public class ProducerConsumer {
    private Object lock = new Object();
    private boolean hasData = false;
    
    public void produce() {
        synchronized (lock) {
            while (hasData) {
                try {
                    lock.wait(); // 等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 生产数据
            hasData = true;
            lock.notify(); // 通知消费者
        }
    }
    
    public void consume() {
        synchronized (lock) {
            while (!hasData) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 消费数据
            hasData = false;
            lock.notify();
        }
    }
}

线程池

使用线程池可以复用线程，提高性能。

ExecutorService

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

ExecutorService executor = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        System.out.println("任务执行: " + Thread.currentThread().getName());
    });
}

executor.shutdown();

ThreadPoolExecutor

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.LinkedBlockingQueue;

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // 核心线程数
    10, // 最大线程数
    60L, // 空闲线程存活时间
    TimeUnit.SECONDS, // 时间单位
    new LinkedBlockingQueue<>() // 工作队列
);

并发集合

Java 提供了线程安全的集合类：

• ConcurrentHashMap：线程安全的 HashMap
• CopyOnWriteArrayList：线程安全的 ArrayList
• BlockingQueue：阻塞队列

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);

原子类

Java 提供了原子类来保证操作的原子性：

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // 原子操作

总结

Java 多线程编程是构建高性能应用的关键技术。理解线程的创建、同步、通信以及线程池的使用，可以帮助开发者编写出高效、安全的并发程序。