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

原创秒速五厘米 2024-09-17 01:06 55阅读 0赞

在Java的并发编程中，信号量(Semaphore)是一种用于管理共享资源的机制。它类似于锁，但是可以控制同时访问资源的数量。

以下是一个简单的信号量示例：

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

public class SemaphoreExample {
    private final Semaphore permit = new Semaphore(1);

public void acquirePermit() throws InterruptedException {
        permit.acquire();
    }

public void releasePermit() {
        permit.release();
    }
    
    public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        
        // Acquire permit
        Thread thread1 = new Thread(() -> {
            try {
                example.acquirePermit();
                System.out.println("Thread 1: Permitted to use resource");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

// Acquire permit again, but resource is limited
        Thread thread2 = new Thread(() -> {
            try {
                example.acquirePermit();
                System.out.println("Thread 2: Permitted to use resource");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (!example.isResourceAvailable()) {
                // If resource is no longer available, release permit
                example.releasePermit();
                System.out.println("Thread 2: Resource not available. Released permit.");
            }
        }));

thread1.start();
        thread2.start();

// Wait until both threads finish
        thread1.join();
        thread2.join();
    }

// Method to check if resource is available
    private boolean isResourceAvailable() {
        return permit.available(1);
    }
}
```

这个示例中，我们创建了一个信号量`permit`，初始值为1。这意味着最多只能有一个线程（在这里是两个线程）获得许可去使用资源。

`acquirePermit()`方法会尝试获取信号量的许可证，如果当前资源可用，那么许可证就会被成功获取。

在主线程中，我们等待所有线程执行完毕。这可以通过使用`join()`方法来实现。