Java中的并发控制：如何使用Semaphore与CountDownLatch优化线程安全

Java中的并发控制：如何使用Semaphore与CountDownLatch优化线程安全

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

在多线程编程中，如何有效地控制线程的执行顺序和资源访问是一个关键问题。Java 提供了多种并发控制工具，其中 Semaphore 和 CountDownLatch 是两个非常有用的类。它们在实现线程安全、协调线程之间的合作方面起着重要作用。本文将详细介绍这两个工具的使用方式，并提供相应的代码示例。

Semaphore：控制资源的访问量

Semaphore 是一种用于限制同时访问某个资源的线程数量的工具。它基于“信号量”的概念，通过维护一个计数器来控制对共享资源的访问。当一个线程请求访问资源时，如果计数器大于0，计数器将减1，并允许该线程访问资源；如果计数器等于0，线程将阻塞，直到有其他线程释放资源。

使用示例：

package cn.juwatech.concurrent;

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    private static final int MAX_PERMITS = 3;
    private static final Semaphore semaphore = new Semaphore(MAX_PERMITS);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Worker(i)).start();
        }
    }

    static class Worker implements Runnable {
        private final int workerId;

        Worker(int workerId) {
            this.workerId = workerId;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("Worker " + workerId + " is accessing the resource.");
                Thread.sleep(2000); // 模拟资源访问
                System.out.println("Worker " + workerId + " is releasing the resource.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                semaphore.release();
            }
        }
    }
}

在上述代码中，我们创建了一个 Semaphore 对象，并设置最大许可数 MAX_PERMITS 为3。这意味着最多允许3个线程同时访问资源。当 Worker 线程尝试访问资源时，必须先调用 semaphore.acquire() 获取许可，如果许可数量不足，线程将阻塞等待。访问完成后，线程会调用 semaphore.release() 释放许可，从而让其他线程继续访问资源。

CountDownLatch：实现线程的协调与同步

CountDownLatch 是一种用于协调多个线程之间相互等待的工具。它基于一个计数器，这个计数器的初始值由主线程设定。每当一个线程完成任务后，计数器会减1，直到计数器变为0，所有等待的线程才会继续执行。

使用示例：

package cn.juwatech.concurrent;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    private static final int TOTAL_WORKERS = 5;
    private static final CountDownLatch latch = new CountDownLatch(TOTAL_WORKERS);

    public static void main(String[] args) {
        for (int i = 0; i < TOTAL_WORKERS; i++) {
            new Thread(new Worker(i, latch)).start();
        }

        try {
            latch.await(); // 主线程等待，直到所有工作线程完成
            System.out.println("All workers have finished their tasks. Main thread continues.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    static class Worker implements Runnable {
        private final int workerId;
        private final CountDownLatch latch;

        Worker(int workerId, CountDownLatch latch) {
            this.workerId = workerId;
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                System.out.println("Worker " + workerId + " is performing task.");
                Thread.sleep(2000); // 模拟工作任务
                System.out.println("Worker " + workerId + " has finished the task.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                latch.countDown(); // 任务完成，计数器减1
            }
        }
    }
}

在这个例子中，我们使用了 CountDownLatch 来确保所有 Worker 线程在主线程继续执行之前完成它们的任务。CountDownLatch 的计数器初始值设置为 TOTAL_WORKERS。每个 Worker 线程完成任务后，调用 latch.countDown() 使计数器减1，直到所有线程都完成任务，主线程才会解除等待状态并继续执行。

Semaphore与CountDownLatch的区别

虽然 Semaphore 和 CountDownLatch 都可以用来协调多个线程，但它们的使用场景和目的有所不同。

• Semaphore 主要用于控制对共享资源的并发访问，限制同时访问资源的线程数量。
• CountDownLatch 主要用于同步多个线程，确保某些任务在其他线程完成之前不会执行。

总结

在Java并发编程中，Semaphore 和 CountDownLatch 是非常有用的工具，它们各自解决了线程同步与资源管理中的不同问题。通过合理使用这些工具，可以更好地控制多线程环境下的执行流程和资源共享，从而提升系统的并发性能和稳定性。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！