Java中锁的类型详解

ReentrantLock fairLock = new ReentrantLock(true); // true表示公平锁

ReentrantReadWriteLock fairReadWriteLock = new ReentrantReadWriteLock(true);

Semaphore fairSemaphore = new Semaphore(permits, true); // true表示公平

// 公平锁示例
ReentrantLock lock = new ReentrantLock(true);
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock();
}

ReentrantLock lock = new ReentrantLock(false); // false表示非公平锁

// 非公平锁
ReentrantLock nonFairLock = new ReentrantLock(false);
// 公平锁
ReentrantLock fairLock = new ReentrantLock(true);

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

public synchronized void exclusiveMethod() {
    // 临界区代码
}

public void exclusiveBlock() {
    synchronized (this) {
        // 临界区代码
    }
}

private final ReentrantLock lock = new ReentrantLock();
public void performTask() {
    lock.lock(); // 获取锁
    try {
        // 临界区代码
    } finally {
        lock.unlock(); // 确保锁释放
    }
}

lock.lockInterruptibly(); // 响应中断的锁获取

if (lock.tryLock(1, TimeUnit.SECONDS)) { // 尝试在指定时间内获取锁
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }
}

ReentrantLock fairLock = new ReentrantLock(true); // 公平锁

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock(); // 共享锁
ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock(); // 排他锁

// 示例：使用共享锁实现线程安全的缓存
class Cache<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    public V get(K key) {
        rwLock.readLock().lock();
        try {
            return map.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    public void put(K key, V value) {
        rwLock.writeLock().lock();
        try {
            map.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

StampedLock stampedLock = new StampedLock();
long stamp = stampedLock.tryOptimisticRead(); // 乐观读锁
if (!stampedLock.validate(stamp)) {
    stamp = stampedLock.readLock(); // 退化为悲观读锁
}

public synchronized void updateData() {
    // 临界区代码
}

public void updateData() {
    synchronized (this) { // 锁住当前对象
        // 临界区代码
    }
}

private final ReentrantLock lock = new ReentrantLock();
public void updateData() {
    lock.lock(); // 手动加锁
    try {
        // 临界区代码
    } finally {
        lock.unlock(); // 必须手动释放
    }
}

Connection conn = ...;
try {
    conn.setAutoCommit(false);
    PreparedStatement ps = conn.prepareStatement(
        "SELECT * FROM accounts WHERE id = ? FOR UPDATE"
    );
    ps.setInt(1, accountId);
    ResultSet rs = ps.executeQuery();
    // 修改数据后提交
    conn.commit();
} catch (SQLException e) {
    conn.rollback();
}

// 假设有一个实体类
public class Product {
    private Long id;
    private String name;
    private int version; // 乐观锁版本号
}
// 更新逻辑
@Transactional
public void updateProduct(Long id, String newName) {
    Product product = productDao.selectById(id);
    product.setName(newName);
    int updated = productDao.updateWithVersion(product);
    if (updated == 0) {
        throw new OptimisticLockException("更新失败，数据已被修改");
    }
}

UPDATE product SET name = #{newName}, version = version + 1 
WHERE id = #{id} AND version = #{oldVersion};

private AtomicInteger counter = new AtomicInteger(0);
public void increment() {
    int oldValue, newValue;
    do {
        oldValue = counter.get();
        newValue = oldValue + 1;
    } while (!counter.compareAndSet(oldValue, newValue));
}

ReentrantLock lock = new ReentrantLock(); // 非公平锁
lock.lock(); // 获取锁
try {
    // 临界区代码
} finally {
    lock.unlock(); // 确保锁释放
}

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 操作临界区
    } finally {
        lock.unlock();
    }
} else {
    // 处理超时逻辑
}

try {
    lock.lockInterruptibly();
    // 临界区代码
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 恢复中断状态
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

ReentrantLock fairLock = new ReentrantLock(true); // 公平锁
fairLock.lock();
try {
    // 公平锁保护的代码
} finally {
    fairLock.unlock();
}

public class NonReentrantLock {
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait(); // 若锁被占用，当前线程等待
        }
        isLocked = true; // 获取锁
    }
    public synchronized void unlock() {
        isLocked = false;
        notify(); // 唤醒等待线程
    }
}

NonReentrantLock lock = new NonReentrantLock();
lock.lock();
lock.lock(); // 线程在此处永久阻塞