当前位置：首页 > news >正文

Java 多线程开发

news 2026/5/11 19:10:10

Java 多线程开发是 Java 并发编程的核心内容，用于实现程序的并发执行，提高 CPU 利用率和系统吞吐量。以下是 Java 多线程开发的系统性介绍：

一、为什么需要多线程？

提升性能：充分利用多核 CPU 资源。
响应性：UI 线程不阻塞（如 Swing/JavaFX 中后台任务）。
异步处理：如网络请求、文件 I/O、定时任务等。
建模现实问题：如生产者-消费者、银行转账等并发场景。

二、创建线程的两种基本方式

1. 实现`Runnable`接口（推荐）

Runnabletask=()->System.out.println("Hello from thread: "+Thread.currentThread().getName());Threadt=newThread(task);t.start();

2. 继承`Thread`类（不推荐）

classMyThreadextendsThread{publicvoidrun(){System.out.println("Running in "+getName());}}newMyThread().start();

✅最佳实践：优先使用Runnable+Thread或更高级的并发工具（如线程池）。

三、线程的生命周期（6 种状态）

状态	说明
`NEW`	线程刚创建，未调用`start()`
`RUNNABLE`	可运行（包括正在运行或等待 CPU 时间片）
`BLOCKED`	等待获取监视器锁（如进入`synchronized`块）
`WAITING`	无限期等待（如`wait()`,`join()`,`LockSupport.park()`）
`TIMED_WAITING`	限时等待（如`sleep(1000)`,`wait(1000)`）
`TERMINATED`	线程执行完毕或异常终止

可通过Thread.getState()查看状态。

四、线程同步机制（解决共享资源竞争）

1.`synchronized`关键字

修饰实例方法：锁当前对象（this）
修饰静态方法：锁类的Class对象
同步代码块：synchronized(obj) { ... }，可指定任意锁对象

⚠️ 静态与非静态synchronized方法不互斥（锁对象不同）。

2.`volatile`关键字

保证变量的可见性和禁止指令重排序
不保证原子性（如i++仍需同步）

3.`java.util.concurrent.locks.Lock`

更灵活的显式锁（如ReentrantLock）
支持尝试获取锁、超时、公平锁等

Locklock=newReentrantLock();lock.lock();try{// 临界区}finally{lock.unlock();// 必须在 finally 中释放}

五、线程间通信

1.`wait()`/`notify()`/`notifyAll()`

必须在synchronized块中调用
wait()释放锁并进入等待队列
notify()唤醒一个等待线程

2.`Condition`（配合`Lock`使用）

Locklock=newReentrantLock();Conditioncondition=lock.newCondition();// 等待lock.lock();try{condition.await();}finally{lock.unlock();}// 唤醒condition.signal();// 或 signalAll()

六、高级并发工具（`java.util.concurrent`包）

1. 线程池（核心！）

避免频繁创建/销毁线程，提升性能。

ExecutorServiceexecutor=Executors.newFixedThreadPool(4);executor.submit(()->{// 任务逻辑});executor.shutdown();

常用工厂方法：

newFixedThreadPool(n)：固定大小线程池
newCachedThreadPool()：弹性线程池（适合短任务）
newSingleThreadExecutor()：单线程顺序执行
生产建议：使用ThreadPoolExecutor自定义参数（避免Executors的隐藏风险）

2. 并发集合

ConcurrentHashMap：线程安全的 HashMap
CopyOnWriteArrayList：读多写少场景
BlockingQueue：如ArrayBlockingQueue,LinkedBlockingQueue（常用于生产者-消费者）

3. 同步工具类

CountDownLatch：等待 N 个任务完成
CyclicBarrier：多个线程互相等待到达屏障点
Semaphore：控制同时访问资源的线程数
CompletableFuture：异步编程（Java 8+）

七、常见问题与最佳实践

❌ 常见陷阱

死锁（多个锁顺序不一致）
活锁 / 饥饿
内存可见性问题（忘记volatile或同步）
过度同步（性能下降）

✅ 最佳实践

优先使用并发工具类（如ConcurrentHashMap而非Collections.synchronizedMap）
缩小同步范围：只同步必要代码
避免在构造函数中启动线程
使用线程池管理线程，而非手动创建
命名线程：便于调试（new Thread(runnable, "MyWorker")）
处理中断：响应InterruptedException，不要忽略

八、示例：生产者-消费者模型（使用`BlockingQueue`）

BlockingQueue<Integer>queue=newArrayBlockingQueue<>(10);// 生产者Threadproducer=newThread(()->{try{for(inti=0;i<20;i++){queue.put(i);// 阻塞直到有空间System.out.println("Produced: "+i);}}catch(InterruptedExceptione){Thread.currentThread().interrupt();}});// 消费者Threadconsumer=newThread(()->{try{while(!Thread.currentThread().isInterrupted()){Integeritem=queue.take();// 阻塞直到有元素System.out.println("Consumed: "+item);}}catch(InterruptedExceptione){Thread.currentThread().interrupt();}});producer.start();consumer.start();