Java并发工具类Lock和Semaphore的区别与使用示例

原创今天药忘吃喽~ 2024-11-22 13:24 19阅读 0赞

Lock和Semaphore都是Java中常用的并发工具，但它们的作用和使用场景有所不同。

1. Lock（锁）：
- 作用：Lock主要用于控制对共享资源的访问，保证同一时刻只有一个线程能够访问该资源。
- 使用示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

public void readResource() {
        try {
            // 获取锁
            lock.lock();
            // 确保在此期间只有一个线程访问资源
            System.out.println("Reading resource...");
        } catch (InterruptedException e) {
            // 处理中断异常
            e.printStackTrace();
            lock.unlock();  // 释放锁，确保资源恢复原状
        } finally {
            // 无论是否发生异常，最后都要尝试解锁以归还资源
            try {
                lock.unlock();
                System.out.println("Resource unlocked.");
            } catch (Exception e) {
                // 处理解锁时的异常
                e.printStackTrace();
            }
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.readResource();  // 调用读资源方法获取锁并访问资源
    }
}
```

2. Semaphore（信号量）：
- 作用：Semaphore主要用于控制同时访问共享资源的线程数量，当达到预设的最大并发数时，后续请求会受到阻塞。
- 使用示例：
```java
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(2);  // 初始化信号量，允许最大2个线程同时访问资源

public void accessResource() throws InterruptedException {
        try {
            // 请求信号量
            semaphore.acquire();
            System.out.println("Accessing resource...");
        } catch (Exception e) {
            // 处理请求失败的异常
            e.printStackTrace();
            // 释放信号量，确保后续线程能够再次访问资源
            semaphore.release();
        }
    }

public static void main(String[] args) throws InterruptedException {
        SemaphoreExample example = new SemaphoreExample();
        // 创建一个CountDownLatch，当信号量被请求并成功获取后（semaphore.acquire()），它将计数减1，并启动一个等待它的线程
        CountDownLatch latch = new CountDownLatch(1);
        Thread t = new Thread(() -> {
            try {
                // 请求信号量
                semaphore.acquire();
                System.out.println("Acquired semaphore...");
                // 将CountDownLatch的计数减1
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));
        t.start();  // 启动线程t

// 等待信号量被请求并成功获取，然后释放信号量
        latch.await();

// 当CountDownLatch的计数减为0时，表示所有信号量都被正确地请求和获取了。此时可以安全地释放信号量资源
        semaphore.release();
    }
}
```

以上示例展示了如何使用Lock（锁）和Semaphore（信号量）工具进行并发控制。