Java中的锁类型及其特点

概述

在Java多线程编程中，锁是一种重要的同步机制，用于控制多个线程对共享资源的访问，以保证数据的一致性和线程安全。Java提供了多种锁机制，每种锁都有其特定的适用场景和特点。

按特性分类：悲观锁 vs 乐观锁

悲观锁：

• 特点：总是假设最坏的情况，认为数据在操作时一定会被其他线程修改，所以在操作数据前先加锁
• 实现：synchronized关键字和ReentrantLock等都是悲观锁的实现
• 适用场景：写操作频繁，冲突较多的场景
• 优点：保证数据一致性，实现简单
• 缺点：可能导致线程阻塞，性能较低

乐观锁：

• 特点：总是假设最好的情况，认为数据在操作时不会被其他线程修改，所以不加锁，在更新数据时检查是否有其他线程修改了数据
• 实现：通常通过CAS（Compare-And-Swap）操作实现，如AtomicInteger等原子类
• 适用场景：读操作频繁，冲突较少的场景
• 优点：不会导致线程阻塞，性能较高
• 缺点：实现复杂，可能存在ABA问题

按实现方式分类：synchronized关键字 vs ReentrantLock

synchronized关键字：

• 特点：Java内置的关键字，使用简单，自动获取和释放锁
• 实现原理：基于对象头中的Mark Word和Monitor机制实现
• 锁类型：非公平锁、可重入锁、不可中断锁
• 锁升级过程：偏向锁 → 轻量级锁 → 重量级锁
• 优点：使用简单，自动释放锁，不易出错
• 缺点：功能相对单一，灵活性不足

public class SynchronizedExample {
    private final Object lock = new Object();
    
    public void method() {
        // 同步代码块
        synchronized(lock) {
            // 临界区代码
        }
    }
    
    // 同步方法
    public synchronized void synchronizedMethod() {
        // 临界区代码
    }
}

ReentrantLock：

• 特点：Java并发包中的显式锁，提供了更丰富的功能
• 实现原理：基于AQS（AbstractQueuedSynchronizer）实现
• 锁类型：可重入锁，可选择公平或非公平，可中断锁
• 优点：功能丰富，灵活性高，可尝试获取锁，可定时获取锁
• 缺点：需要手动释放锁，使用不当可能导致死锁

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock(true); // true表示公平锁
    
    public void method() {
        lock.lock(); // 获取锁
        try {
            // 临界区代码
        } finally {
            lock.unlock(); // 释放锁
        }
    }
    
    public void tryLockMethod() {
        if (lock.tryLock()) { // 尝试获取锁，立即返回
            try {
                // 临界区代码
            } finally {
                lock.unlock();
            }
        } else {
            // 获取锁失败的处理
        }
    }
}

按锁状态分类：偏向锁、轻量级锁、重量级锁

这是synchronized关键字在JVM层面的锁状态，表示锁的不同优化级别：

偏向锁：

• 特点：假设锁总是由同一个线程获取，减少同一线程获取锁的代价
• 适用场景：只有一个线程访问同步块的场景
• 优点：性能高，几乎无额外开销
• 缺点：在竞争激烈时，会升级为轻量级锁，增加额外开销

轻量级锁：

• 特点：当有另一个线程竞争锁时，偏向锁会升级为轻量级锁，竞争线程通过自旋尝试获取锁
• 适用场景：线程交替执行同步块，竞争不激烈的场景
• 优点：线程不会阻塞，响应速度快
• 缺点：自旋会消耗CPU资源，在竞争激烈时性能下降

重量级锁：

• 特点：当自旋一定次数后仍未获取到锁，轻量级锁会升级为重量级锁，竞争线程会阻塞
• 适用场景：线程竞争激烈的场景
• 优点：不会消耗CPU资源进行自旋
• 缺点：线程阻塞和唤醒的开销大，性能较低

按锁功能分类

可重入锁：

• 特点：同一线程可以多次获取同一把锁，不会导致死锁
• 实现：synchronized和ReentrantLock都是可重入锁
• 优点：避免死锁，简化编程模型
• 缺点：可能导致锁的滥用，降低并发性能

public class ReentrantExample {
    private final Object lock = new Object();
    
    public void outerMethod() {
        synchronized(lock) {
            innerMethod(); // 同一线程再次获取锁，不会阻塞
        }
    }
    
    public void innerMethod() {
        synchronized(lock) {
            // 临界区代码
        }
    }
}

读写锁：

• 特点：将锁分为读锁和写锁，允许多个线程同时读，但只允许一个线程写
• 实现：ReentrantReadWriteLock
• 适用场景：读多写少的场景
• 优点：提高读操作的并发性
• 缺点：写操作会阻塞所有读操作，可能导致写线程饥饿

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    
    public void readOperation() {
        readLock.lock();
        try {
            // 读操作
        } finally {
            readLock.unlock();
        }
    }
    
    public void writeOperation() {
        writeLock.lock();
        try {
            // 写操作
        } finally {
            writeLock.unlock();
        }
    }
}

公平锁 vs 非公平锁：

• 公平锁：

  • 特点：按照线程请求锁的顺序来分配锁，先到先得
  • 实现：ReentrantLock(true)
  • 优点：避免线程饥饿，保证公平性
  • 缺点：吞吐量较低，维护有序队列的开销大

• 非公平锁：

  • 特点：不保证按照请求顺序分配锁，允许插队
  • 实现：synchronized和ReentrantLock(false)
  • 优点：吞吐量高，减少线程上下文切换
  • 缺点：可能导致线程饥饿

共享锁 vs 排他锁：

• 共享锁：

  • 特点：允许多个线程同时持有锁
  • 实现：读锁是共享锁的典型实现
  • 适用场景：读多写少的场景
  • 优点：提高并发读的性能
  • 缺点：写操作需要等待所有读锁释放

• 排他锁：

  • 特点：一次只允许一个线程持有锁
  • 实现：synchronized、写锁等
  • 适用场景：写操作或需要独占资源的场景
  • 优点：保证数据一致性
  • 缺点：并发性能较低

Java并发包中的锁实现

ReentrantLock：

• 特点：可重入的独占锁，提供了比synchronized更丰富的功能
• 主要方法：lock()、unlock()、tryLock()、lockInterruptibly()
• 优点：可中断、可定时、可实现公平锁
• 适用场景：需要synchronized的高级功能时

ReentrantReadWriteLock：

• 特点：可重入的读写锁，分离了读锁和写锁
• 实现原理：基于AQS，使用同一个状态变量的高16位表示读状态，低16位表示写状态
• 优点：提高读操作的并发性
• 适用场景：读多写少的场景

StampedLock：

• 特点：Java 8新增的锁，提供了乐观读、悲观读和写三种模式
• 实现原理：使用stamp（票据）来表示锁的状态
• 优点：性能优于ReentrantReadWriteLock，避免了写线程饥饿问题
• 缺点：不支持重入，使用复杂

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock stampedLock = new StampedLock();
    private double value;
    
    public void writeValue(double newValue) {
        long stamp = stampedLock.writeLock(); // 获取写锁
        try {
            value = newValue;
        } finally {
            stampedLock.unlockWrite(stamp); // 释放写锁
        }
    }
    
    public double readValue() {
        long stamp = stampedLock.tryOptimisticRead(); // 尝试乐观读
        double currentValue = value;
        if (!stampedLock.validate(stamp)) { // 检查乐观读期间是否有写操作
            stamp = stampedLock.readLock(); // 获取悲观读锁
            try {
                currentValue = value;
            } finally {
                stampedLock.unlockRead(stamp); // 释放读锁
            }
        }
        return currentValue;
    }
}

Condition：

• 特点：与锁关联的条件变量，提供了更灵活的线程等待/通知机制
• 实现：ReentrantLock.newCondition()
• 主要方法：await()、signal()、signalAll()
• 优点：支持多个等待队列，可精确唤醒指定线程
• 适用场景：需要更复杂的线程间协作时

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean flag = false;
    
    public void awaitMethod() throws InterruptedException {
        lock.lock();
        try {
            while (!flag) {
                condition.await(); // 等待条件满足
            }
            // 条件满足后的操作
        } finally {
            lock.unlock();
        }
    }
    
    public void signalMethod() {
        lock.lock();
        try {
            flag = true;
            condition.signal(); // 通知等待的线程
        } finally {
            lock.unlock();
        }
    }
}

LockSupport：

• 特点：提供了基本的线程阻塞和唤醒功能
• 主要方法：park()、unpark(Thread thread)
• 优点：不会导致死锁，更底层的线程控制
• 适用场景：构建更高级的同步工具

import java.util.concurrent.locks.LockSupport;

public class LockSupportExample {
    public void parkAndUnpark() {
        Thread thread = Thread.currentThread();
        
        new Thread(() -> {
            try {
                Thread.sleep(1000);
                LockSupport.unpark(thread); // 唤醒指定线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        LockSupport.park(); // 阻塞当前线程
        System.out.println("Thread is unparked");
    }
}

各种锁的适用场景和选择建议

synchronized：

• 适用场景：简单的同步需求，对性能要求不高的场景
• 选择理由：使用简单，自动释放锁，不易出错

ReentrantLock：

• 适用场景：需要可中断锁、定时锁、公平锁等高级功能的场景
• 选择理由：功能丰富，灵活性高

ReentrantReadWriteLock：

• 适用场景：读多写少的场景，如缓存系统
• 选择理由：提高读操作的并发性

StampedLock：

• 适用场景：读多写少且对性能要求高的场景
• 选择理由：性能优于ReentrantReadWriteLock，避免了写线程饥饿问题

乐观锁（CAS）：

• 适用场景：冲突较少的高并发场景
• 选择理由：无阻塞，性能高

悲观锁：

• 适用场景：写操作频繁，冲突较多的场景
• 选择理由：保证数据一致性，实现简单