【Java中锁的分类】

**Java 中锁的分类**

在 Java 中，锁是用于同步多线程访问共享资源的一种机制。锁可以帮助我们避免由于多线程访问共享资源而导致的数据不一致问题。在本文中，我们将讨论 Java 中锁的分类。

###1. **Synchronized 锁**

`Synchronized` 锁是最基本也是最常用的锁类型。它通过在方法或代码块上加锁来实现同步。`Synchronized` 锁可以作用于类、对象或方法。

#### 示例代码：

javapublic class SynchronizedExample {
 private int count =0;

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

 public static void main(String[] args) throws InterruptedException {
 final SynchronizedExample example = new SynchronizedExample();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println(example.count); // 输出:20000 }
}

在上面的示例中，我们使用 `synchronized` 锁来保护 `increment()` 方法。由于两个线程都访问同一个 `SynchronizedExample` 对象，因此它们之间的访问是同步的。

###2. **ReentrantLock 锁**

`ReentrantLock` 锁是一种可重入锁（也称为自旋锁）。它比 `synchronized` 锁更灵活，可以在多个线程之间共享一个锁。`ReentrantLock` 锁可以通过 `lock()` 和 `unlock()` 方法来手动管理。

#### 示例代码：

javaimport java.util.concurrent.locks.ReentrantLock;

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

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

 public static void main(String[] args) throws InterruptedException {
 final ReentrantLockExample example = new ReentrantLockExample();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println(example.count); // 输出:20000 }
}

在上面的示例中，我们使用 `ReentrantLock` 锁来保护 `increment()` 方法。由于两个线程都访问同一个 `ReentrantLockExample` 对象，因此它们之间的访问是同步的。

###3. **Lock 锁**

`Lock` 锁是一种高级锁类型，提供了比 `synchronized` 锁更灵活的功能。它可以在多个线程之间共享一个锁，并且可以手动管理锁的获取和释放。

#### 示例代码：

javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

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

 public static void main(String[] args) throws InterruptedException {
 final LockExample example = new LockExample();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 example.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println(example.count); // 输出:20000 }
}

在上面的示例中，我们使用 `Lock` 锁来保护 `increment()` 方法。由于两个线程都访问同一个 `LockExample` 对象，因此它们之间的访问是同步的。

### 总结Java 中锁的分类包括 `Synchronized` 锁、`ReentrantLock` 锁和 `Lock` 锁。每种锁类型都有其特点和使用场景。通过选择合适的锁类型，可以有效地避免多线程访问共享资源导致的数据不一致问题。

### 参考* Java API Documentation: [java.util.concurrent.locks.Lock]( />* Java API Documentation: [java.util.concurrent.locks.ReentrantLock](