Java并发工具类（如Semaphore，CountDownLatch等）使用实例

原创矫情吗；* 2025-03-20 18:06 65阅读 0赞

在Java中，常用的并发工具类包括`Semaphore`、`CountDownLatch`和`ReentrantLock`。下面将通过几个实例来演示它们的使用。

1. **Semaphore** (信号量)
Semaphore是一种有限资源的同步工具，主要用于控制同时访问某个资源的最大数量。

例子：
```java
// 创建一个信号量，初始值为5
Semaphore semaphore = new Semaphore(5);

// 线程A：尝试获取信号量5次
Thread threadA = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        // 如果信号量大于0，成功获取，否则阻塞
        if (semaphore.tryAcquire()) {
            System.out.println("Thread A: Success to get semaphore");
            break;
        }
    }
}));
```
2. **CountDownLatch** (计数器下落)
CountDownLatch用于多个线程同步，当所有线程执行完毕后，会调用一个预先设置的回调方法。

例子：
```java
// 创建一个计数器，初始值为3
CountDownLatch countDown = new CountDownLatch(3);

// 线程A、B：各自执行任务，并使计数器减1
Thread threadA = new Thread(() -> {
    try {
        countDown.countDown();
        System.out.println("Thread A: Successfully decremented counter");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
Thread threadB = new Thread(() -> {
    try {
        countDown.countDown();
        System.out.println("Thread B: Successfully decremented counter");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
// 启动线程
threadA.start();
threadB.start();

// 等待所有线程执行完毕后调用方法
countDown.await();

System.out.println("All threads completed, ending program...");
```
3. **ReentrantLock** (可重入锁)
ReentrantLock是一种基于公平原则的互斥同步工具。它可以被多次锁定和解锁，且在同一个锁下进行操作是安全的。

例子：
```java
// 创建一个可重入锁
ReentrantLock lock = new ReentrantLock();

// 线程A：尝试获取锁并打印
Thread threadA = new Thread(() -> {
    try {
        // 获取锁（如果当前线程持有锁，则直接获得）
        lock.lock();
        System.out.println("Thread A: Successfully locked the lock");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 无论是否获取到锁，最后都要尝试解锁
        try {
            lock.unlock();
            System.out.println("Thread A: Successfully unlocked the lock");
        } catch (Exception e) {
            System.err.println("Error unlocking lock: " + e.getMessage());
        }
    });
});

// 线程B：尝试获取锁并打印
Thread threadB = new Thread(() -> {
    try {
        // 获取锁（如果当前线程持有锁，则直接获得）
        lock.lock();
        System.out.println("Thread B: Successfully locked the lock");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 无论是否获取到锁，最后都要尝试解锁
        try {
            lock.unlock();
            System.out.println("Thread B: Successfully unlocked the lock");
        } catch (Exception e) {
            System.err.println("Error unlocking lock: " + e.getMessage());
        }
    });
});

// 启动线程
threadA.start();
threadB.start();

// 等待所有线程执行完毕后调用方法
lock.unlock(); // 在所有线程都完成解锁后调用，确保锁被完全释放

System.out.println("All threads completed, ending program...");
```
总结：
Java并发工具类如Semaphore、CountDownLatch和ReentrantLock在多线程编程中扮演着重要角色。通过这些工具的使用，可以更加方便地管理线程间的互斥关系。