什么是Java中的线程
Java中线程是程序执行的最小单元，它是进程中的一个独立执行路径。在Java中，每个线程都有自己的调用栈，但同一进程内的所有线程共享堆内存。这种共享内存模型使得线程间通信变得相对简单，但也带来了线程安全等挑战。
Java线程的实现基于两个主要方式：
1. 继承Thread类
2. 实现Runnable接口
线程的基本特性
Java线程具有以下关键特性：
- 轻量级：创建和销毁线程的开销比进程小
- 共享内存：同一进程的线程共享堆内存和方法区
- 独立执行：每个线程有自己的程序计数器和栈
- 优先级：Java线程可以设置优先级(1-10)
Java线程的生命周期与状态转换
理解Java中线程的生命周期对编写健壮的多线程程序至关重要。Java线程在其生命周期中会经历以下几种状态：
新建状态(NEW)
当线程对象被创建但尚未调用start()方法时，线程处于新建状态。此时系统还未为线程分配资源。
```java
Thread thread = new Thread(); // 线程处于NEW状态
### 可运行状态(RUNNABLE)
调用start()方法后，线程进入可运行状态。这个状态包含两个子状态：
- READY：等待CPU时间片
- RUNNING：正在执行
### 阻塞状态(BLOCKED)
当线程试图获取一个内部对象锁而该锁被其他线程持有时，线程进入阻塞状态。
### 等待状态(WAITING)
线程进入等待状态有三种方式：
1. 调用Object.wait()
2. 调用Thread.join()
3. 调用LockSupport.park()
### 超时等待状态(TIMED_WAITING)
与WAITING类似，但带有超时时间：
- Thread.sleep(long)
- Object.wait(long)
- Thread.join(long)
### 终止状态(TERMINATED)
线程执行完毕或异常退出后进入终止状态。
## Java线程的创建与启动
在Java中创建线程主要有三种方式：
### 继承Thread类
```java
class MyThread extends Thread {
public void run() {
// 线程执行的代码
}
}
MyThread thread = new MyThread();
thread.start();
实现Runnable接口
class MyRunnable implements Runnable {
public void run() {
// 线程执行的代码
}
}
Thread thread = new Thread(new MyRunnable());
thread.start();
使用Callable和Future
Java 5引入了Callable接口，它允许线程返回结果并抛出异常：
Callable<Integer> task = () -> {
// 执行计算
return 42;
};
FutureTask<Integer> futureTask = new FutureTask<>(task);
Thread thread = new Thread(futureTask);
thread.start();
Integer result = futureTask.get(); // 获取结果
Java线程同步与线程安全
多线程环境下，共享资源的访问需要同步机制来保证线程安全。Java提供了多种同步机制：
synchronized关键字
synchronized是Java中最基本的同步机制，可用于：
- 实例方法
- 静态方法
- 代码块
public synchronized void increment() {
count++; // 线程安全的方法
}
volatile关键字
volatile确保变量的可见性，但不保证原子性：
private volatile boolean running = true;
显式锁(Lock接口)
Java 5引入了更灵活的Lock接口：
Lock lock = new ReentrantLock();
lock.lock();
try {
// 临界区代码
} finally {
lock.unlock();
}
原子变量
java.util.concurrent.atomic包提供了一系列原子类：
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // 原子操作
Java线程池的最佳实践
线程池是管理线程的有效方式，Java通过Executor框架提供了强大的线程池支持。
线程池的优势
- 降低资源消耗：复用已创建的线程
- 提高响应速度：任务到达时线程已存在
- 提高线程可管理性：统一分配、调优和监控
常用线程池类型
// 固定大小线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(5);
// 单线程池
ExecutorService singleThread = Executors.newSingleThreadExecutor();
// 可缓存线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();
// 定时任务线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);
自定义线程池
对于更复杂的需求，可以直接使用ThreadPoolExecutor：
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60, // 空闲线程存活时间
TimeUnit.SECONDS, // 时间单位
new ArrayBlockingQueue<>(100) // 工作队列
);
Java并发工具类
Java并发包(java.util.concurrent)提供了许多强大的工具类：
CountDownLatch
允许一个或多个线程等待其他线程完成操作：
CountDownLatch latch = new CountDownLatch(3);
// 工作线程
latch.countDown();
// 主线程
latch.await();
CyclicBarrier
让一组线程到达一个屏障时被阻塞，直到最后一个线程到达：
CyclicBarrier barrier = new CyclicBarrier(3);
// 工作线程
barrier.await();
Semaphore
控制同时访问特定资源的线程数量：
Semaphore semaphore = new Semaphore(5);
semaphore.acquire();
try {
// 访问资源
} finally {
semaphore.release();
}
Java线程性能优化技巧
编写高效的多线程程序需要考虑以下优化策略：
减少锁竞争
- 缩小同步范围
- 使用读写锁(ReentrantReadWriteLock)
- 采用无锁数据结构
合理设置线程池参数
- 根据任务类型选择线程池
- 合理设置核心线程数和最大线程数
- 选择合适的阻塞队列
避免常见陷阱
- 死锁：避免嵌套锁和循环等待
- 活锁：线程不断重试但无法前进
- 线程饥饿：低优先级线程长期得不到执行
Java线程的未来发展
随着Java版本的更新，线程相关特性也在不断演进：
虚拟线程(Project Loom)
Java 19引入了虚拟线程(轻量级线程)，可以显著提高高并发应用的性能：
Thread.startVirtualThread(() -> {
// 虚拟线程任务
});
结构化并发(Java 21)
结构化并发提供了更安全的并发编程模型：
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Future<String> user = scope.fork(() -> findUser());
Future<Integer> order = scope.fork(() -> fetchOrder());
scope.join();
scope.throwIfFailed();
return new Response(user.resultNow(), order.resultNow());
}
总结
Java中线程是多线程编程的核心概念，掌握线程的生命周期、同步机制和并发工具对于编写高效、安全的并发程序至关重要。随着Java版本的更新，线程相关的API和特性也在不断演进，开发者应当持续关注这些变化，以便充分利用现代Java提供的并发能力。
