java 常用的锁

Java常用的锁

在Java多线程编程中，为了保证线程安全和数据一致性，我们经常会使用到锁。锁是一种同步机制，用于控制对共享资源的访问。Java提供了多种锁的实现，本文将介绍几种常用的锁，并给出相应的代码示例。

1. synchronized锁

synchronized是Java中最基本的锁机制，可以修饰方法或代码块。通过synchronized修饰的方法或代码块，在同一时间只能有一个线程访问，其他线程需要等待锁释放后才能执行。

示例代码：

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

2. ReentrantLock锁

ReentrantLock是Java提供的可重入锁，它具有与synchronized类似的功能，但更加灵活。ReentrantLock提供了更多的扩展功能，例如可定时、可中断的等待锁。

示例代码：

public class ReentrantLockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

3. ReadWriteLock锁

ReadWriteLock是一种读写锁，它允许多个线程同时读取共享资源，但只允许一个线程进行写操作。这种锁适用于读多写少的场景，可以提高并发性能。

示例代码：

public class ReadWriteLockExample {
    private int count = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void increment() {
        lock.writeLock().lock();
        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int getCount() {
        lock.readLock().lock();
        try {
            return count;
        } finally {
            lock.readLock().unlock();
        }
    }
}

4. Condition条件

Condition是Java提供的条件变量，它与锁配合使用，可以实现线程间的等待和通知机制。通过Condition，我们可以精确控制线程的等待和唤醒。

示例代码：

public class ConditionExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void await() throws InterruptedException {
        lock.lock();
        try {
            while (count < 100) {
                condition.await();
            }
        } finally {
            lock.unlock();
        }
    }
}

总结

本文介绍了Java中常用的锁机制，包括synchronized锁、ReentrantLock锁、ReadWriteLock锁和Condition条件。这些锁机制都是为了保证线程安全和数据一致性而设计的。在实际开发中，我们需要根据具体的场景选择合适的锁机制来保护共享资源。

甘特图：

gantt
    dateFormat  YYYY-MM-DD
    title       锁的使用时间表

    section synchronized锁
    synchronized锁      : 2022-01-01, 1d

    section ReentrantLock锁
    ReentrantLock锁    : 2022-01-02, 2d

    section ReadWriteLock锁
    ReadWriteLock锁     : 2022-01-04, 3d

    section Condition条件
    Condition条件       : 2022-01-07, 2d

旅行图：

journey
    title Java常用的锁之旅

    section synchronized锁
    synchronized锁      : Start, 2022-01-01, 1d
    synchronized锁      : End, 2022-01-01, 1d

    section ReentrantLock锁
    ReentrantLock锁    : Start, 2022-01-02, 2d
    ReentrantLock锁    : End, 2022-01-03, 2d

    section ReadWriteLock