Java多线程之间如何共享数据

发布时间：2021-10-31 10:13:12 作者：小新
来源：亿速云阅读：206

# Java多线程之间如何共享数据

## 目录
1. [多线程数据共享概述](#一多线程数据共享概述)
2. [共享数据的问题与挑战](#二共享数据的问题与挑战)
3. [基本共享方式](#三基本共享方式)
4. [线程安全的数据结构](#四线程安全的数据结构)
5. [锁机制详解](#五锁机制详解)
6. [原子变量类](#六原子变量类)
7. [volatile关键字](#七volatile关键字)
8. [ThreadLocal实现线程隔离](#八threadlocal实现线程隔离)
9. [并发容器使用场景](#九并发容器使用场景)
10. [最佳实践与性能考量](#十最佳实践与性能考量)
11. [总结](#十一总结)

---

## 一、多线程数据共享概述

### 1.1 什么是线程间数据共享
在多线程编程中，当多个线程需要访问和操作同一个数据对象时，就形成了线程间的数据共享。这种共享可以是：
- 显式共享：通过公共变量或共享对象
- 隐式共享：通过闭包或回调引用

```java
// 典型共享示例
public class SharedData {
    public static int counter = 0;  // 静态变量共享
}

1.2 共享数据的必要性

状态保持：如计数器、标志位等
资源池化：数据库连接池、线程池等
协作通信：生产者-消费者模式中的数据队列

1.3 JMM（Java内存模型）基础

Java内存模型规定了线程如何与内存交互： - 主内存：存储共享变量 - 工作内存：每个线程私有的内存空间 - happens-before原则：保证可见性的核心规则

二、共享数据的问题与挑战

2.1 竞态条件（Race Condition）

当多个线程无序访问共享数据时，程序的正确性依赖于线程执行的时序。

// 竞态条件示例
if (counter == 5) {
    counter++;  // 非原子操作
}

2.2 内存可见性问题

由于CPU缓存的存在，线程可能看不到其他线程对共享变量的修改。

2.3 死锁与活锁

死锁：四个必要条件（互斥、占有等待、非抢占、循环等待）
活锁：线程不断重试但无法前进

2.4 性能开销

同步机制带来的额外成本： - 上下文切换 - 内存屏障指令 - 锁竞争

三、基本共享方式

3.1 静态变量共享

class GlobalData {
    static volatile int globalCounter;
}

3.2 实例变量共享

class SharedInstance {
    private int value;
    
    public synchronized void increment() {
        value++;
    }
}

3.3 对象传递共享

class DataHolder {
    private Object data;
    
    public void process(Consumer<Object> processor) {
        processor.accept(data);
    }
}

四、线程安全的数据结构

4.1 Concurrent集合类

非线程安全类	线程安全替代
ArrayList	CopyOnWriteArrayList
HashMap	ConcurrentHashMap
HashSet	ConcurrentHashSet

4.2 BlockingQueue实现

BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);
// 生产者
queue.put("item"); 
// 消费者
String item = queue.take();

4.3 ConcurrentMap高级用法

ConcurrentMap<String, AtomicInteger> map = new ConcurrentHashMap<>();
map.computeIfAbsent("key", k -> new AtomicInteger(0)).incrementAndGet();

五、锁机制详解

5.1 synchronized关键字

// 方法同步
public synchronized void syncMethod() {}

// 块同步
synchronized(lockObject) {
    // 临界区代码
}

5.2 ReentrantLock高级特性

Lock lock = new ReentrantLock();
try {
    lock.lock();
    // ...
} finally {
    lock.unlock();
}

5.3 读写锁（ReadWriteLock）

ReadWriteLock rwLock = new ReentrantReadWriteLock();
// 读锁
rwLock.readLock().lock();
// 写锁
rwLock.writeLock().lock();

六、原子变量类

6.1 AtomicInteger使用

AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();

6.2 CAS原理

比较并交换（Compare-And-Swap）的底层实现：

// 伪代码
int compare_and_swap(int* reg, int oldval, int newval) {
    int old_reg_val = *reg;
    if (old_reg_val == oldval)
        *reg = newval;
    return old_reg_val;
}

6.3 LongAdder高性能计数器

LongAdder adder = new LongAdder();
adder.increment();
long sum = adder.sum();

七、volatile关键字

7.1 可见性保证

volatile boolean shutdownRequested;

public void shutdown() {
    shutdownRequested = true;
}

7.2 与synchronized的区别

特性	volatile	synchronized
原子性	无	有
可见性	有	有
互斥性	无	有

八、ThreadLocal实现线程隔离

8.1 基本用法

ThreadLocal<SimpleDateFormat> dateFormat = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

8.2 内存泄漏问题

必须注意remove()的调用：

try {
    // 使用ThreadLocal
} finally {
    threadLocal.remove();
}

九、并发容器使用场景

9.1 CopyOnWriteArrayList适用场景

读多写少
集合较小（因为写时复制开销大）

9.2 ConcurrentHashMap分段锁

JDK 8之前：Segment分段锁 JDK 8+：CAS + synchronized优化

十、最佳实践与性能考量

10.1 减少锁粒度

// 不好
synchronized(this) {
    // 大量代码
}

// 优化
private final Object specificLock = new Object();
synchronized(specificLock) {
    // 最小临界区
}

10.2 避免锁嵌套

// 危险代码
synchronized(lockA) {
    synchronized(lockB) {
        // ...
    }
}

十一、总结

11.1 技术选型建议

场景	推荐方案
计数器	AtomicLong/LongAdder
状态标志	volatile
集合共享	ConcurrentHashMap
复杂同步	ReentrantLock

11.2 未来发展趋势

Project Loom的虚拟线程
Java内存模型持续优化
硬件级并发原语支持

本文完整代码示例及扩展讨论详见：GitHub仓库链接最后更新：2023年6月15日 “`

注：实际文章需要扩展每个章节的详细内容、更多代码示例、性能测试数据、图表说明等以达到万字规模。以上为完整框架和核心内容展示。