Java中并发工具类(如Lock, Semaphore等)使用示例

原创 ╰半夏微凉° 2025-03-20 11:33 101阅读 0赞

在Java中，`java.util.concurrent.locks.Lock` 和 `java.util.concurrent.Semaphore` 是常用的并发工具类。下面以这两个类为例，提供使用示例：

1. 使用Lock进行线程同步

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

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

public void process() throws InterruptedException {
        // 获取锁
        lock.lock();
        try {
            // 执行任务，注意这里的代码会被锁定，直到锁被释放
            System.out.println("Processing task...");
            Thread.sleep(2000);  // 假设这个任务需要执行一段时间

// 任务完成后，解锁
            lock.unlock();
        } catch (Exception e) {
            // 锁无法解锁时，解锁并记录异常
            try {
                lock.unlock();  // 先解锁
                e.printStackTrace();  // 再记录异常
            } catch (Exception e2) {
                // 解锁失败时，记录异常
                e2.printStackTrace();
            }
        }
    }

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

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        thread1.join();
        thread2.join();
    }
}
```

2. 使用Semaphore进行资源控制

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3);  // 初始化，允许的最多等待者数为3

public void process() throws InterruptedException {
        // 请求信号量
        semaphore.acquire();
        try {
            System.out.println("Processing task...");
            Thread.sleep(2000);  // 假设这个任务需要执行一段时间

// 任务完成后，释放信号量
            semaphore.release();
        } catch (Exception e) {
            // 无法获取信号量或释放时出现问题，记录异常并重试
            try {
                semaphore.release();  // 先尝试释放信号量
                e.printStackTrace();  // 再记录异常
            } catch (Exception e2) {
                // 释放失败时，记录异常
                e2.printStackTrace();
            }
        }
    }

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

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        thread1.join();
        thread2.join();
    }
}
```

这些示例展示了如何使用Lock和Semaphore这两种并发工具类。