线程同步问题：Java多线程中的锁与信号量使用示例

原创淩亂°似流年 2024-11-07 12:30 22阅读 0赞

在Java中，线程同步是一个重要的概念，它确保了多个线程在访问共享资源时的一致性和完整性。Java提供了多种机制来实现线程同步，其中锁（Lock）和信号量（Semaphore）是两种常用的同步工具。下面我将分别给出使用锁和信号量的示例。

###1. 使用锁（Lock）

Java的`java.util.concurrent.locks`包提供了`Lock`接口和一些实现了该接口的类，如`ReentrantLock`。以下是使用`ReentrantLock`的一个简单示例：

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

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

public void performAction() {
lock.lock(); // 获取锁 try {
//执行需要同步的代码 System.out.println("Performing action");
} finally {
lock.unlock(); //释放锁 }
 }

public static void main(String[] args) {
LockExample example = new LockExample();
Thread thread1 = new Thread(() -> example.performAction());
Thread thread2 = new Thread(() -> example.performAction());

thread1.start();
 thread2.start();
 }
}
```在这个示例中，`performAction`方法中的代码块被`lock`保护，确保了同一时间只有一个线程可以执行这段代码。

###2. 使用信号量（Semaphore）

信号量用于控制对资源的访问数量。`java.util.concurrent`包中的`Semaphore`类可以用来实现这种控制。以下是使用`Semaphore`的一个示例：

```javaimport java.util.concurrent.Semaphore;

public class SemaphoreExample {
 private final Semaphore semaphore = new Semaphore(1); //允许一个线程访问 public void performAction() {
 try {
 semaphore.acquire(); // 请求一个许可//执行需要同步的代码 System.out.println("Performing action");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
 semaphore.release(); //释放许可 }
 }

public static void main(String[] args) {
SemaphoreExample example = new SemaphoreExample();
Thread thread1 = new Thread(() -> example.performAction());
Thread thread2 = new Thread(() -> example.performAction());

thread1.start();
 thread2.start();
 }
}
```在这个示例中，`semaphore`被初始化为1，意味着同一时间只允许一个线程执行`performAction`方法中的代码。

这两种机制都是线程同步的有效工具，选择哪一种取决于具体的应用场景和需求。锁适用于保护临界区，而信号量适用于控制对资源的并发访问数量。