Java 并发编程ReentrantLock 公平锁与非公平锁深度解析

// 默认非公平
reentrantlock lock1 = new reentrantlock();
// 显式非公平
reentrantlock lock2 = new reentrantlock(false);
// 公平锁
reentrantlock lock3 = new reentrantlock(true);

时刻 1：a 持有锁，等待队列: b -> c -> d
时刻 2：a 释放锁的瞬间，新线程 e 也来抢锁

 ┌─ e 直接插队抢锁 ─┐
         │                 ▼
释放锁 → 队列头: b  c  d   ←  e 抢到了
         │
         └─ 队列里 b/c/d 还在等

时刻 1：a 持有锁，等待队列: b -> c -> d
时刻 2：a 释放锁的瞬间，新线程 e 也来抢锁

释放锁 → 锁交给 b（b 先到，理所当然）
         队列变成: c -> d -> e

// 非公平 lock
final void lock() {
    if (compareandsetstate(0, 1))
        setexclusiveownerthread(thread.currentthread());
    else
        acquire(1);
}
// 公平 lock
final void lock() {
    acquire(1);
}
// 公平 tryacquire
protected final boolean tryacquire(int acquires) {
    final thread current = thread.currentthread();
    int c = getstate();
    if (c == 0) {
        if (!hasqueuedpredecessors() &&  // 关键：有前驱等待线程就放弃抢锁
            compareandsetstate(0, acquires)) {
            setexclusiveownerthread(current);
            return true;
        }
    }
    // ... 可重入逻辑
}

reentrantlock fairlock = new reentrantlock(true);
fairlock.trylock();                 // ❗无视公平策略，可插队
fairlock.trylock(5, timeunit.seconds); // ✅遵守公平排队
fairlock.lock();                    // ✅遵守公平排队

非公平锁：吞吐量 100%
公平锁  ：吞吐量 70% 左右
差异明显，因为唤醒队头的开销占大头。

非公平锁：吞吐量 100%
公平锁  ：吞吐量 95% 左右
差异很小，因为唤醒队头的开销相对临界区可忽略。

private final reentrantlock lock = new reentrantlock();
public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();
    }
}

public object get(string key) {
    object v = cache.get(key);
    if (v == null) {
        lock.lock();
        try {
            v = cache.get(key);
            if (v == null) {
                v = db.query(key);
                cache.put(key, v);
            }
        } finally {
            lock.unlock();
        }
    }
    return v;
}

// 数据库连接池、线程池内部的任务队列
// 锁保护的就是"取出/放入一个对象"的动作

private final map<string, reentrantlock> workspacelockmap = new concurrenthashmap<>();
reentrantlock lock = new reentrantlock(true); // 公平锁
// lock.lockinterruptibly(); // 获取锁过程响应线程中断，无超时，会永久阻塞
// domap(...);   // 出图 5~15 秒
// lock.unlock();

// 多个任务往同一文件写日志
// 多个任务调用同一台打印机

// 同一账户的多个并发扣款
// 必须按用户请求的顺序处理

// 本地缓存代理外部限流接口（每秒只能调 10 次）
// 所有调用方都要排队

锁内操作时间？
├── 极短（ns/μs）
│   └── 业务能容忍饿死吗？
│       ├── 能 → 非公平锁
│       └── 不能 → 公平锁（或换无锁方案）
│
└── 较长（ms/s）
    └── 业务能容忍饿死吗？
        ├── 能 → 非公平锁（性能稍好）
        └── 不能 → 公平锁（推荐）

08:53:15.855  earthquake_epicenter 启动
08:53:15.855  earthquake_epicenter 等待锁（先到）
08:53:18.xxx  eq_station 启动
08:53:18.xxx  eq_station 等待锁（后到）
08:53:38.725  eq_station 拿到锁（先释放的先抢）
08:53:38.725  earthquake_epicenter 还在等
08:53:50.xxx  eq_fracture 启动（更晚到）
08:53:50.xxx  eq_fracture 直接抢到锁（插队！）
08:53:50.xxx  earthquake_epicenter 还在等
08:54:00.865  eq_fracture 释放
08:54:15.862  earthquake_epicenter 60s 超时放弃
08:54:24.xxx  eq_traffic 才完成（最后才轮到）

reentrantlock lock = new reentrantlock(true);  // 公平锁
lock.lockinterruptibly();                       // 获取锁过程响应线程中断，无超时，会永久阻塞
try {
    domapinner(...);                            // 出图
} finally {
    lock.unlock();
}

reentrantlock lock = new reentrantlock(true);
boolean locked = lock.trylock(60, timeunit.seconds);
if (!locked) {
    throw new timeoutexception("获取工作空间锁超时60s");
}
try {
    domapinner(...);
} finally {
    lock.unlock();
}

08:53:15.855  earthquake_epicenter 入队
08:53:18.xxx  eq_station 入队
08:53:50.xxx  eq_fracture 入队
释放锁后按顺序出锁：
  1. earthquake_epicenter（先到先服务）✅
  2. eq_station
  3. eq_fracture
  ...
每张图最终都会轮到，不会饿死。

public class fairlockdemo {
    private final reentrantlock lock = new reentrantlock(true);
    public void dowork() {
        lock.lock();
        try {
            // 临界区
        } finally {
            lock.unlock();
        }
    }
}

private void domap(string eqid, string eqtaskid, string filepath, string maptype,
                   string eqtime, string eqaddr, string eqlon, string eqlat,
                   string eqdepth, string eqmag, string maptitle,
                   map<string, object> mapstyle, workspace workspace, string workspacepath) throws timeoutexception, interruptedexception {
    reentrantlock lock = workspacelockmap.get(workspacepath);
    if (lock == null) {
        synchronized (workspacelockmap) {
            lock = workspacelockmap.get(workspacepath);
            if (lock == null) {
                lock = new reentrantlock(true); // 公平锁
                workspacelockmap.put(workspacepath, lock);
            }
        }
    }
    boolean locked = false;
    try {
        log.info("【{}】等待工作空间锁 | path={}", maptype, workspacepath);
        // 公平锁，最多等待60秒，响应中断
        locked = lock.trylock(60, timeunit.seconds);
        if (!locked) {
            throw new timeoutexception("获取工作空间锁超时60s, path:" + workspacepath);
        }
        log.info("【{}】拿到工作空间锁 | path={}", maptype, workspacepath);
        domapinner(eqid, eqtaskid, filepath, maptype, eqtime, eqaddr,
                eqlon, eqlat, eqdepth, eqmag, maptitle, mapstyle, workspace, workspacepath);
    } finally {
        if (locked) {
            lock.unlock();
        }
    }
}

private boolean isrecoverableexception(throwable t) {
    if (t == null) return false;
    string msg = t.getmessage();
    if (msg == null) return false;
    string low = msg.tolowercase();
    return low.contains("workspace")
        || low.contains("datasource")
        || low.contains("timeout");
        // 提示：线上环境异常栈多为英文，不建议匹配中文关键字"锁、工作空间"，会出现匹配失效
}