Java中锁的使用

• Java提供了多种锁机制来实现多线程同步和互斥。
  • synchronized关键字
  • ReentrantLock
  • ReentrantReadWriteLock
  • Semaphore
  • CountDownLatch
  • 以上是Java中常用的锁机制，不同的锁机制适用于不同的场景。在使用锁时，需要注意避免死锁、饥饿等问题，保证程序的正确性和效率。

Java提供了多种锁机制来实现多线程同步和互斥。

这些锁机制包括synchronized关键字、ReentrantLock【锐安屯】、ReentrantReadWriteLock、Semaphore【C莫法儿】、CountDownLatch等。下面分别介绍这些锁机制的使用方法：

synchronized关键字

1. synchronized是Java中最简单的锁机制，它可以用来实现方法或者代码块的同步。synchronized关键字的使用方式有两种
   • 一种是在方法声明中使用，另一种是在代码块中使用。
   • 在方法声明中使用synchronized关键字：

public synchronized void method() {
    // 方法体
}

2. 在代码块中使用synchronized关键字：其中，lock是一个共享的对象，synchronized关键字会对object进行加锁，在临界区代码执行期间，其他线程无法访问object。

public class SynchronizedExample {
    public void doSomething(Object lock) {
        synchronized (lock) {
            // 临界区
        }
    }
}

ReentrantLock

1. ReentrantLock是Java中一个可重入的互斥锁，它提供了比synchronized更加灵活的同步方式。使用ReentrantLock需要先创建一个ReentrantLock对象，然后使用lock()方法获得锁，在finally块中使用unlock()方法释放锁。

private final ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 临界区
    } finally {
        lock.unlock();
    }
}

ReentrantReadWriteLock

1. ReentrantReadWriteLock是Java中一个可重入的读写锁，它提供了比ReentrantLock更加高效的读写操作。使用ReentrantReadWriteLock需要先创建一个ReentrantReadWriteLock对象，然后使用readLock()方法获得读锁，使用writeLock()方法获得写锁，在finally块中使用unlock()方法释放锁。

private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

public void readMethod() {
    lock.readLock().lock();
    try {
        // 读操作
    } finally {
        lock.readLock().unlock();
    }
}

public void writeMethod() {
    lock.writeLock().lock();
    try {
        // 写操作
    } finally {
        lock.writeLock().unlock();
    }
}

Semaphore

1. Semaphore是Java中一个计数信号量，它可以用来控制对某个共享资源的访问。Semaphore有一个初始的计数值，每次使用Semaphore时，计数值会减一，当计数值为0时，其他线程将无法访问共享资源。

private final Semaphore semaphore = new Semaphore(10);

public void method() throws InterruptedException {
    semaphore.acquire(); // 获取信号量
    try {
        // 访问共享资源
    } finally {
        semaphore.release(); // 释放信号量
    }
}

CountDownLatch

1. CountDownLatch是Java中一个同步辅助类，它可以用来等待一组线程执行完毕再继续执行。CountDownLatch有一个初始的计数值，每次调用countDown()方法时，计数值会减一，当计数值为0时，等待线程将被释放。

private final CountDownLatch latch = new CountDownLatch(10);

public void method() throws InterruptedException {
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            // 执行任务
            latch.countDown(); // 计数器减一
        }).start();
    }
    latch.await(); // 等待计数器归零
    // 所有任务执行完毕
}

以上是Java中常用的锁机制，不同的锁机制适用于不同的场景。在使用锁时，需要注意避免死锁、饥饿等问题，保证程序的正确性和效率。