如何在Java中实现多线程资源共享_技术教程

使用synchronized、ReentrantLock、volatile及线程安全类可实现Java多线程资源共享。1. synchronized保证方法或代码块互斥执行；2. ReentrantLock提供更灵活的显式锁机制；3. volatile确保变量可见性，适用于状态标志；4. AtomicInteger等原子类支持高效原子操作。根据场景选择：简单计数用AtomicInteger，复杂同步用synchronized或ReentrantLock，状态通知用volatile，避免并发问题。

在Java中实现多线程资源共享，核心在于保证多个线程对共享数据的访问是安全的。如果不加以控制，多个线程同时读写同一资源可能导致数据不一致、脏读或竞态条件等问题。以下是几种常见且有效的实现方式。

使用 synchronized 关键字

synchronized 是Java中最基础的线程同步机制，它可以保证同一时刻只有一个线程能执行某个方法或代码块。

你可以将它用于实例方法、静态方法或代码块：

修饰实例方法：锁住当前对象实例（this）
修饰静态方法：锁住类的Class对象
修饰代码块：手动指定锁对象

示例：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

这样多个线程调用 increment() 时会互斥执行，避免了并发修改问题。

使用 ReentrantLock 显式锁

ReentrantLock 是 java.util.concurrent.locks 包中的可重入锁，比 synchronized 更灵活，支持公平锁、尝试获取锁、超时获取等高级功能。

示例：

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

注意：必须在 finally 块中释放锁，防止死锁。

使用 volatile 关键字（适用于简单场景）

volatile 能保证变量的可见性，但不能保证原子性。适合用于状态标志位等不需要复合操作的场景。

例如：

private volatile boolean running = true;

public void stop() {
    running = false;
}

一个线程修改 running，其他线程能立即看到最新值。

但像 count++ 这种操作，volatile 无法解决并发问题，因为它包含读-改-写三个步骤。

使用线程安全的类和容器

Java 提供了许多线程安全的工具类，可以直接使用，避免自己实现同步逻辑。

AtomicInteger、AtomicLong：提供原子性的整数操作
ConcurrentHashMap：高性能的线程安全Map
BlockingQueue：用于线程间安全传递数据

示例：

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
}

这种方式性能好，代码简洁，推荐在合适场景下优先使用。

基本上就这些。选择哪种方式取决于具体需求：如果只是简单计数，用 AtomicInteger；需要复杂同步逻辑，用 synchronized 或 ReentrantLock；共享状态通知，考虑 volatile。关键是理解每种机制的适用边界，避免过度同步或同步不足。