Java并发编程：信号量机制的使用示例

原创女爷i 2024-11-23 12:51 1阅读 0赞

在Java并发编程中，信号量（Semaphore）是一种同步原语，用于控制对共享资源的访问。它主要用于线程间的互斥和同步。

以下是一个简单的信号量机制的使用示例：

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

public class SemaphoreExample {
    private Semaphore permit1 = new Semaphore(1);
    private Semaphore permit2 = new Semaphore(1);

public void threadA() throws InterruptedException {
        // 请求许可，如果可用则获得，否则阻塞
        permit1.acquire();

System.out.println("Thread A executing...");

// 执行任务
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 允许信号量被释放，这将导致等待的线程恢复运行
        permit1.release();
    }

public void threadB() throws InterruptedException {
        // 请求许可，如果可用则获得，否则阻塞
        permit2.acquire();

System.out.println("Thread B executing...");

// 允许信号量被释放，这将导致等待的线程恢复运行
        permit2.release();
    }

public static void main(String[] args) throws InterruptedException {
        SemaphoreExample example = new SemaphoreExample();

CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

Thread threadA = new Thread(() -> {
            example.threadA();
            latch1.countDown();
        }));

Thread threadB = new Thread(() -> {
            example.threadB();
            latch2.countDown();
        }));

threadA.start();
        threadB.start();

latch1.await(); // 等待threadA执行完成
        latch2.await(); // 等待threadB执行完成

System.out.println("Example finished.");
    }
}
```

这个示例中，两个线程（Thread A 和 Thread B）分别通过信号量`permit1`和`permit2`进行互斥访问共享资源。当一个线程完成任务后，会调用相应的信号量方法释放信号量，使得等待的线程得以执行。

Java并发编程：信号量机制的使用示例

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java并发编程：Semaphore信号量示例

相关 Java并发编程：信号量机制的使用示例

相关 Java并发编程：锁和信号量示例

相关 Java并发编程中信号量机制的实际应用示例

相关 Java并发编程中的锁和信号量使用示例

相关 Java并发控制：信号量（Semaphore）的使用示例

相关 Java并发编程中的信号量机制误用案例

相关 Java并发编程中信号量机制详解实例

相关并发编程中信号量机制示例

相关 Java并发编程：信号量（Semaphore）示例分析