Java多线程并发编程：锁、信号量的理解

原创痛定思痛。 2024-11-12 09:51 221阅读 0赞

Java多线程并发编程是Java编程中的一个重要部分，它涉及到多个线程同时执行时的资源共享和同步问题。锁（Locks）和信号量（Semaphores）是Java并发编程中常用的两种同步机制，它们帮助控制对共享资源的访问，以避免数据不一致和竞态条件。

###锁（Locks）

在Java中，锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程需要访问共享资源时，它会首先尝试获取锁。如果锁已经被其他线程持有，那么请求锁的线程将被阻塞，直到锁被释放。

Java提供了多种锁的实现，包括：

1. **内置锁（synchronized）**：Java语言层面的锁机制，通过`synchronized`关键字实现。它既可以用于方法，也可以用于代码块。
2. **ReentrantLock**：`java.util.concurrent.locks.ReentrantLock`类提供了与`synchronized`关键字类似的功能，但它提供了更多的扩展功能，如尝试非阻塞获取锁、可中断的锁获取、公平性等。

###信号量（Semaphores）

信号量是一种更为通用的同步机制，它控制了对一定数量的资源的访问。信号量维护了一组许可证，每个线程在访问资源前必须获取一个许可证，访问完毕后释放许可证。

Java中的信号量实现是`java.util.concurrent.Semaphore`类。信号量可以用于：

1. **限制资源访问的线程数量**：例如，限制同时访问数据库连接的线程数。
2. **控制任务的执行顺序**：通过信号量控制某些任务必须在其他任务完成后才能执行。

###锁与信号量的区别- **功能**：锁主要用于保护临界区，确保同一时间只有一个线程可以访问共享资源；信号量则用于控制对一组资源的访问，可以有多个许可证。
- **许可证数量**：锁通常只有一个许可证（即一次只能有一个线程持有锁），而信号量可以有多个许可证。
- **使用场景**：锁适用于简单的互斥控制，信号量适用于更复杂的资源管理和任务调度。

### 示例代码#### 使用`synchronized`关键字实现锁```javapublic class Counter {
 private int count =0;

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

public synchronized int getCount() {
 return count;
 }
}
```#### 使用`ReentrantLock`实现锁```javaimport java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private final 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();
 }
 }
}
```#### 使用`Semaphore`实现信号量```javaimport java.util.concurrent.Semaphore;

public class ResourcePool {
 private final Semaphore semaphore;

public ResourcePool(int permits) {
 semaphore = new Semaphore(permits);
 }

public void useResource() throws InterruptedException {
 semaphore.acquire();
 try {
// 使用资源} finally {
 semaphore.release();
 }
 }
}
```理解锁和信号量是掌握Java并发编程的关键，它们帮助开发者编写出更安全、更高效的并发程序。