Java编程语言中多线程同步机制详解与实战指南-源码库

Java多线程同步机制详解与实战：从理论到代码的完整指南

为什么我们需要多线程同步？

记得我第一次写多线程程序时，遇到了一个奇怪的问题：两个线程同时操作一个银行账户，结果余额莫名其妙少了钱。经过调试才发现，这是因为线程在执行”读取-修改-写入”操作时发生了交错执行。这就是典型的线程安全问题，而同步机制就是解决这个问题的关键。

synchronized关键字：最基础的同步工具

synchronized是Java中最常用的同步机制，我习惯把它比作”会议室的门牌”——拿到门牌的人才能进入会议室。在实际项目中，我通常这样使用：

public class BankAccount {
    private double balance;
    
    // 同步方法
    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println("存款成功，当前余额：" + balance);
    }
    
    // 同步代码块
    public void withdraw(double amount) {
        synchronized(this) {
            if(balance >= amount) {
                balance -= amount;
                System.out.println("取款成功，当前余额：" + balance);
            }
        }
    }
}

踩坑提示：我曾经在一个项目中过度使用synchronized，导致性能严重下降。后来发现，应该尽量缩小同步范围，只在真正需要同步的代码块上加锁。

Lock接口：更灵活的同步选择

相比synchronized，Lock接口提供了更丰富的功能。特别是在需要尝试获取锁、定时获取锁的场景下，Lock表现出色。这是我的常用写法：

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

public class ThreadSafeCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println("计数器值：" + count);
        } finally {
            lock.unlock(); // 确保锁被释放
        }
    }
}

实战经验：一定要在finally块中释放锁！我曾经因为异常导致锁没有被释放，造成了死锁，排查了整整一天。

volatile关键字：轻量级的可见性保证

volatile不能保证原子性，但能保证可见性。在标志位控制的场景中特别有用：

public class TaskRunner implements Runnable {
    private volatile boolean running = true;
    
    @Override
    public void run() {
        while(running) {
            // 执行任务
            System.out.println("任务执行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public void stop() {
        running = false;
    }
}

实战案例：生产者消费者模式

让我们通过一个完整的例子来巩固所学知识。这是我最近项目中用到的生产者消费者实现：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MessageQueue {
    private final Queue queue = new LinkedList<>();
    private final int capacity;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    
    public MessageQueue(int capacity) {
        this.capacity = capacity;
    }
    
    public void produce(String message) throws InterruptedException {
        lock.lock();
        try {
            while(queue.size() == capacity) {
                notFull.await(); // 队列满时等待
            }
            queue.offer(message);
            System.out.println("生产消息：" + message);
            notEmpty.signalAll(); // 通知消费者
        } finally {
            lock.unlock();
        }
    }
    
    public String consume() throws InterruptedException {
        lock.lock();
        try {
            while(queue.isEmpty()) {
                notEmpty.await(); // 队列空时等待
            }
            String message = queue.poll();
            System.out.println("消费消息：" + message);
            notFull.signalAll(); // 通知生产者
            return message;
        } finally {
            lock.unlock();
        }
    }
}