java 锁面试要点

// 1. 修饰实例方法：锁当前对象 this
public synchronized void method() {}

// 2. 修饰静态方法：锁当前 Class 对象
public static synchronized void staticMethod() {}

// 3. 修饰代码块：锁指定对象
public void block() {
    synchronized (lock) { }
}

synchronized (lock) {
    // 代码
}

monitorenter
// 代码
monitorexit

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

// 对象头 Mark Word（64 位）
// 偏向锁：| 线程ID(54) | Epoch(2) | 未使用(1) | 分代年龄(4) | 偏向标志(1) | 锁标志(2) |

// 轻量级锁 Mark Word
// | 指向栈中锁记录的指针(62) | 锁标志(2) = 00 |

// 伪代码
while (!cas(lock, unlocked, locked)) {
    // 自旋
}

ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.lock(); // 可重入
lock.unlock();
lock.unlock();

// ReentrantLock 非公平锁
final boolean nonfairTryAcquire(int acquires) {
    if (state == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) {
        setState(state + acquires); // 重入
        return true;
    }
    return false;
}

ReentrantLock fair = new ReentrantLock(true);   // 公平
ReentrantLock unfair = new ReentrantLock(false); // 非公平（默认）

ReentrantLock lock = new ReentrantLock();
if (lock.tryLock()) { // 立即返回
    try { /* 业务 */ }
    finally { lock.unlock(); }
} else {
    // 获取失败，做其他事
}

// 带超时
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try { /* 业务 */ }
    finally { lock.unlock(); }
}

lock.lockInterruptibly();
try {
    // 若被中断，抛 InterruptedException
} finally {
    lock.unlock();
}

// 错误
lock.lock();
doSomething(); // 抛异常，锁永远不释放
lock.unlock();

// 正确
lock.lock();
try {
    doSomething();
} finally {
    lock.unlock();
}

public abstract class AbstractQueuedSynchronizer {
    private volatile int state;          // 同步状态
    private transient volatile Node head; // 队列头
    private transient volatile Node tail; // 队列尾
}

head → node1 → node2 → ... → tail

// 独占：state 0→1
// 共享：state 表示可用许可数，可多个线程同时减

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&           // 1. 尝试获取
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) { 
        // 2. 失败则入队，自旋/阻塞
        selfInterrupt();
    }
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {              // 1. 尝试释放
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);          // 2. 唤醒后继节点
        return true;
    }
    return false;
}

// 从尾部往前找有效节点
Node s = node.next;
if (s == null || s.waitStatus > 0) {
    s = null;
    for (Node t = tail; t != null && t != node; t = t.prev)
        if (t.waitStatus <= 0) s = t;
}

final boolean nonfairTryAcquire(int acquires) {
    if (compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
    // ...
}

protected final boolean tryAcquire(int acquires) {
    if (getState() == 0 && !hasQueuedPredecessors() 
        && compareAndSetState(0, acquires)) {
        // 只有队列为空才抢
    }
}

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReadLock readLock = rwLock.readLock();
WriteLock writeLock = rwLock.writeLock();

readLock.lock();   // 共享
readLock.unlock();

writeLock.lock();  // 独占
writeLock.unlock();

// state 高16位：读锁持有数
// state 低16位：写锁重入次数
static final int SHARED_SHIFT   = 16;
static final int EXCLUSIVE_MASK = (1 << 16) - 1;

// 读锁数量
static int sharedCount(int c) { 
    return c >>> SHARED_SHIFT; 
}
// 写锁数量
static int exclusiveCount(int c) { 
    return c & EXCLUSIVE_MASK; 
}

// 锁降级
writeLock.lock();
try {
    // 修改数据
    readLock.lock();  // 获取读锁
} finally {
    writeLock.unlock(); // 释放写锁，仍持有读锁
}
try {
    // 读数据
} finally {
    readLock.unlock();
}

ReentrantReadWriteLock fair = 
    new ReentrantReadWriteLock(true);

StampedLock lock = new StampedLock();
long stamp = lock.tryOptimisticRead(); // 乐观读
int data = readData();
if (!lock.validate(stamp)) { // 检查是否被修改
    stamp = lock.readLock(); // 降级为悲观读
    try { data = readData(); }
    finally { lock.unlockRead(stamp); }
}

// 伪代码
boolean cas(int expected, int newValue) {
    if (value == expected) {
        value = newValue;
        return true;
    }
    return false;
}

// ABA 问题示例
AtomicInteger ai = new AtomicInteger(1);
// 线程1：读到1，准备 CAS 为 2
// 线程2：1→2→1
// 线程1：CAS(1, 2) 成功，但中间已变过

AtomicStampedReference<Integer> ref = 
    new AtomicStampedReference<>(1, 0);

int stamp = ref.getStamp();
ref.compareAndSet(1, 2, stamp, stamp + 1);

public class AtomicInteger {
    private volatile int value;
    
    public final int getAndIncrement() {
        return U.getAndAddInt(this, VALUE, 1);
    }
    
    // Unsafe 方法
    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }
}

LongAdder adder = new LongAdder();
adder.increment();
long sum = adder.sum(); // 累加所有 Cell

// 伪代码
public void increment() {
    Cell[] as; long b, v; int m; Cell a;
    if ((as = cells) != null || 
        !casBase(b = base, b + 1)) {
        // 竞争激烈，使用 Cell
        int index = getProbe() & (as.length - 1);
        casCell(as[index], 1);
    }
}

AtomicReference<String> ref = new AtomicReference<>("A");

// CAS 更新
boolean success = ref.compareAndSet("A", "B");

// 获取并更新
String old = ref.getAndSet("C");

// 函数式更新
ref.updateAndGet(s -> s + "!");

// 可中断版本
public final void acquireInterruptibly(int arg) {
    if (Thread.interrupted()) throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg); // 阻塞时检查中断
}

await: 同步队列 → 等待队列
signal: 等待队列 → 同步队列

class Mutex extends AbstractQueuedSynchronizer {
    @Override
    protected boolean tryAcquire(int arg) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(
                Thread.currentThread());
            return true;
        }
        return false;
    }

    @Override
    protected boolean tryRelease(int arg) {
        if (getState() == 0) 
            throw new IllegalMonitorStateException();
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock()   { acquire(1); }
    public void unlock() { release(1); }
}

private volatile int state;