Java并发编程核心技术：synchronized、volatile与CAS

发布时间：2025-05-08 02:22:26
本文热度：浏览 121 赞 0 评论 0
文章标签： Java 并发编程多线程
全文共1字，阅读约需1分钟

同步原语基础原理

对象内存结构与监视器机制

在Java虚拟机规范中，每个对象实例都包含对象头、实例数据和填充对齐三部分。对象头中的Mark Word（标记字段）是实现同步机制的关键存储区域，其结构随对象状态变化：

32位JVM Mark Word布局：

|-------------------------------------------------------|--------------------|
|                  Mark Word (32 bits)                  |       State        |
|-------------------------------------------------------|--------------------|
| identity_hashcode:25 | age:4 | biased_lock:0 | lock:01|       Normal       |
|-------------------------------------------------------|--------------------|
|  thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:01|       Biased       |
|-------------------------------------------------------|--------------------|
|               ptr_to_lock_record:30             | lock:00| Lightweight Locked |
|-------------------------------------------------------|--------------------|
|               ptr_to_heavyweight_monitor:30     | lock:10| Heavyweight Locked |
|-------------------------------------------------------|--------------------|

监视器锁（Monitor）的实现依赖这个结构：

当线程进入同步块时，JVM尝试通过CAS操作将Mark Word更新为指向当前线程的指针
更新失败时膨胀为重量级锁，涉及操作系统互斥量（mutex）操作
等待队列采用cxq（Contention queue）和EntryList双队列结构管理竞争线程

内存可见性本质

现代CPU架构的多级缓存结构：

+---------------+    +---------------+    +---------------+
|   CPU Core 1  |    |   CPU Core 2  |    |   CPU Core N  |
|  L1 Cache     |    |  L1 Cache     |    |  L1 Cache     |
|  (32KB)       |    |  (32KB)       |    |  (32KB)       |
+-------+-------+    +-------+-------+    +-------+-------+
        |                    |                    |
        +--------------------+--------------------+
                    L2 Cache (256KB)
                    +-------------------+
                    |                   |
                    +-------------------+
                            |
                    +-------------------+
                    |    L3 Cache       |
                    |    (8-32MB)       |
                    +-------------------+
                            |
                    +-------------------+
                    |   Main Memory     |
                    |   (DRAM)          |
                    +-------------------+

缓存一致性协议（MESI）的状态转换：

Modified（M）：缓存行已被修改，与主存不一致
Exclusive（E）：缓存行独占，与主存一致
Shared（S）：缓存行被多个核心共享
Invalid（I）：缓存行无效

示例代码演示可见性问题：

public class VisibilityDemo {
    // 移除volatile观察不同表现
    private static /*volatile*/ boolean ready = false;
    private static int number = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (!ready) {
                // 空循环或添加Thread.yield()观察效果差异
            }
            System.out.println("Number: " + number);
        }).start();

        number = 42;
        ready = true;
    }
}

synchronized深度解析

锁升级过程详解

偏向锁（Biased Locking）

对象首次被线程访问时，通过CAS将Mark Word中的线程ID设置为当前线程
批量重偏向（bulk rebias）机制：当一类对象的偏向锁撤销超过阈值（默认20次），JVM会重新分配偏向

轻量级锁（Lightweight Locking）

创建Lock Record于线程栈帧中，存储对象Mark Word拷贝
通过CAS将对象头指向Lock Record指针
自旋锁优化：自适应自旋（Adaptive Spinning）根据历史成功率调整自旋次数

重量级锁（Heavyweight Lockoring）

对象关联的monitor结构：

ObjectMonitor() {
    _header       = NULL;
    _count        = 0;  // 重入次数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;  // 持有线程
    _WaitSet      = NULL;  // 等待队列（调用wait()）
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;  // 竞争队列
    FreeNext      = NULL ;
    _EntryList    = NULL ;  // 处于等待锁的线程
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
}

锁优化技术

锁消除（Lock Elision） JIT编译器通过逃逸分析判断同步块是否线程安全

public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();  // 自动消除锁操作
}

锁粗化（Lock Coarsening）连续多个同步块合并为单个同步块：

// 优化前
for (int i = 0; i < 100; i++) {
    synchronized(lock) {
        // 操作
    }
}

// 优化后
synchronized(lock) {
    for (int i = 0; i < 100; i++) {
        // 操作
    }
}

适应性自旋（Adaptive Spinning）

成功率预测：根据最近自旋获取锁的成功率调整自旋时间
自旋上限：JDK 6之后由JVM自动控制，默认10次

volatile内存语义实现

内存屏障实现细节

x86架构下的内存屏障实现：

StoreStore屏障：无实际指令（x86保证写顺序）
LoadLoad屏障：无实际指令
LoadStore屏障：无实际指令
StoreLoad屏障：对应lock; addl $0,0(%%rsp)指令

JVM插入屏障策略：

// 写操作前
StoreStore屏障
// 写操作
// 写操作后
StoreLoad屏障

// 读操作前
LoadLoad屏障
LoadStore屏障
// 读操作

可见性保证示例

缓存失效协议实现：

class VolatileExample {
    int x = 0;
    volatile boolean v = false;

    public void writer() {
        x = 42;
        v = true;  // StoreStore屏障在此插入
    }

    public void reader() {
        if (v) {   // LoadLoad屏障在此插入
            System.out.println(x);
        }
    }
}

CAS操作原理与实现

硬件层实现机制

x86架构的LOCK CMPXCHG指令时序：

锁定总线或使用缓存一致性协议
比较目标地址值与期望值
相等时执行交换操作
释放总线锁定

CPU缓存行对齐优化：

// 伪共享问题示例
class FalseSharing {
    volatile long x;  // 缓存行（64字节）
    volatile long y;  // 可能与x处于同一缓存行
}

// 填充优化方案
class PaddedAtomicLong extends AtomicLong {
    public volatile long p1, p2, p3, p4, p5, p6;  // 填充物
    public PaddedAtomicLong() { super(); }
    public volatile long value;
    public volatile long q1, q2, q3, q4, q5, q6;
}

ABA问题解决方案

带标记的原子引用实现：

AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

// 线程1
int[] stampHolder = new int[1];
String current = ref.get(stampHolder);
ref.compareAndSet(current, "B", stampHolder[0], stampHolder[0]+1);

// 线程2修改A->B->A
ref.compareAndSet("A", "B", 0, 1);
ref.compareAndSet("B", "A", 1, 2);

// 再次尝试修改将失败，因为版本号已变化
ref.compareAndSet("A", "C", 0, 1);  // 预期stamp=0，实际stamp=2

并发控制策略对比

性能对比测试数据

使用JMH基准测试（纳秒/操作）： | 实现方式 | 单线程 | 4线程竞争 | 16线程竞争 | |----------------|--------|-----------|------------| | synchronized | 15 | 1200 | 8500 | | ReentrantLock | 20 | 950 | 6200 | | AtomicInteger | 8 | 45 | 300 | | LongAdder | 12 | 25 | 50 |

（测试环境：Intel i9-9900K, 32GB DDR4, JDK 11）

适用场景决策树

graph TD
    A[需要原子操作?] -->|是| B{操作复杂度}
    B -->|简单| C[考虑CAS]
    B -->|复杂| D[使用锁机制]
    A -->|否| E{需要可见性保证?}
    E -->|是| F[volatile修饰]
    E -->|否| G[普通变量]
    C --> H{竞争激烈程度?}
    H -->|低| I[保持CAS]
    H -->|高| J[转换为LongAdder]
    D --> K{需要灵活控制?}
    K -->|是| L[使用ReentrantLock]
    K -->|否| M[synchronized]

高级优化技巧

锁分解（Lock Splitting）

class ImprovedServerStatus {
    private final Object usersLock = new Object();
    private final Object queriesLock = new Object();
    private int activeUsers;
    private int runningQueries;

    public void updateUsers() {
        synchronized(usersLock) {
            activeUsers++;
        }
    }

    public void updateQueries() {
        synchronized(queriesLock) {
            runningQueries++;
        }
    }
}

无锁数据结构示例

Michael-Scott非阻塞队列实现：

public class NonBlockingQueue<T> {
    private static class Node<T> {
        final T item;
        volatile Node<T> next;

        Node(T item) {
            this.item = item;
        }
    }

    private volatile Node<T> head;
    private volatile Node<T> tail;

    public NonBlockingQueue() {
        Node<T> dummy = new Node<>(null);
        head = dummy;
        tail = dummy;
    }

    public void enq(T item) {
        Node<T> node = new Node<>(item);
        while (true) {
            Node<T> last = tail;
            Node<T> next = last.next;
            if (last == tail) {
                if (next == null) {
                    if (CAS(last.next, next, node)) {
                        CAS(tail, last, node);
                        return;
                    }
                } else {
                    CAS(tail, last, next);
                }
            }
        }
    }

    public T deq() {
        while (true) {
            Node<T> first = head;
            Node<T> last = tail;
            Node<T> next = first.next;
            if (first == head) {
                if (first == last) {
                    if (next == null) return null;
                    CAS(tail, last, next);
                } else {
                    T item = next.item;
                    if (CAS(head, first, next)) return item;
                }
            }
        }
    }

    // 基于Unsafe的CAS实现
    private static final Unsafe UNSAFE = ...;
    private static final long tailOffset = ...;
    
    boolean CAS(Node<T> target, Node<T> expect, Node<T> update) {
        return UNSAFE.compareAndSwapObject(target, tailOffset, expect, update);
    }
}

常见问题排查

死锁检测

使用JStack检测死锁：

jstack <pid> | grep -A 10 deadlock

# 典型输出
Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x00007f88d8004818 (object 0x000000076eaf8a40, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x00007f88d8006208 (object 0x000000076eaf8a50, a java.lang.Object),
  which is held by "Thread-1"

性能问题诊断

使用JFR（Java Flight Recorder）监控锁竞争：

JFR.configure()
    .enable("jdk.JavaMonitorWait")
    .withPeriod(Duration.ofSeconds(1))
    .build()
    .start();

正文到此结束

所属分类：Java学习

本文链接： https://refblogs.com/article/1095
版权声明： 本文由老牛原创发布，转载或复制请以超链接形式转载,并注明出处搬砖的码农。