如何使用Java中的可重入锁实现线程同步

一、什么是可重入锁

在Java并发编程中，锁是常用的一种同步机制，它可以保证多个线程之间的协作。可重入锁是一种特殊的锁，它支持重进入。当一个线程持有一个锁，并且再次请求该锁时，这个请求将会成功。如果不支持重进入，那么请求锁的线程将会一直等待，导致死锁。

Java的可重入锁是通过ReentrantLock类来实现的，它能够保证线程安全和可重入性。下面我们来看一个简单的示例：

public class ReentrantLockDemo {
  private ReentrantLock lock = new ReentrantLock();
  public void method1() {
    lock.lock();
    try {
      // do something
    } finally {
      lock.unlock();
    }
  }
  public void method2() {
    lock.lock();
    try {
      // do something else
    } finally {
      lock.unlock();
    }
  }
}

在上面的示例中，我们使用了ReentrantLock来保证了method1和method2方法的线程安全性和重进入性。

二、可重入锁的使用场景

可重入锁在实际开发中有很多使用场景，比如：

1. 实现同步

上面的示例已经给出了一个基本的使用场景。当多个线程同时调用一个对象的同步方法时，它们会竞争锁。只有一个线程能够获得锁，其他线程将会阻塞。但如果在同一个线程中，它可以多次获得锁，这就是可重入锁的重进入性。

2. 实现读写锁

读写锁在读多写少的情况下，比普通锁有更好的性能。Java中的ReentrantReadWriteLock就是一个读写锁，它内部有两个锁：一个读锁和一个写锁。当多个线程都想要获取读锁时，所有线程将会获得锁。但当线程想要获取写锁时，只有一个线程能够获得锁，其他线程将会阻塞。

3. 实现分段锁

分段锁是一种控制并发访问的方式。在实际开发中，我们可能会将一个大的数据结构分成多个小的数据结构，然后对每个小的数据结构加锁。这样可以减少锁竞争，提升并发能力。

三、可重入锁的注意事项

在使用可重入锁时，需要注意以下几点：

1. 加锁和解锁必须成对出现

每一个lock()方法调用必须对应一个unlock()方法调用，否则会导致死锁。

2. 避免重复解锁

在使用可重入锁时，如果一个线程重复解锁一个锁，将会导致异常。因此，必须确保每个线程只调用一次unlock()方法。

3. 避免死锁

在使用可重入锁时，必须避免死锁。这可以通过避免不必要的加锁、给锁设置超时时间、约定锁的获取顺序等方式实现。

四、可重入锁的代码示例

下面是一个简单的示例，展示如何使用可重入锁实现线程同步：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
  private ReentrantLock lock = new ReentrantLock();
  private int count = 0;
  
  public void increment() {
    lock.lock();
    try {
      count++;
    } finally {
      lock.unlock();
    }
  }
  
  public int getCount() {
    lock.lock();
    try {
      return count;
    } finally {
      lock.unlock();
    }
  }
  
  public static void main(String[] args) throws InterruptedException {
    ReentrantLockExample example = new ReentrantLockExample();
    Thread thread1 = new Thread(() -> {
      for (int i = 0; i < 100000; i++) {
        example.increment();
      }
    });
    Thread thread2 = new Thread(() -> {
      for (int i = 0; i < 100000; i++) {
        example.increment();
      }
    });
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println(example.getCount());
  }
}

在上面的示例中，我们使用ReentrantLock来保证increment方法的线程安全性，实现了对count变量的同步访问。