多线程（69）如何使用synchronized实现信号量

短命女 2024-04-24 23:17 36阅读 0赞

在Java中，信号量（Semaphore）是一种常用的同步工具，它可以用来控制对共享资源的访问数量。信号量主要用于两个目的：一个是用于多个共享资源的互斥使用，另一个是用于并发线程数的控制。虽然Java的`java.util.concurrent`包提供了`Semaphore`类，但了解如何手动实现一个信号量可以帮助更深入地理解并发编程的原理。

下面，我们将使用`Synchronized`关键字来实现一个简单的信号量。我们的目标是实现一个计数信号量，其中信号量的计数指示可以同时访问某一资源的线程数。

#### 实现基本框架 ####

首先，我们定义一个`Semaphore`类，它需要维护一个计数器来跟踪可用的许可证数量。计数器的初始值在信号量创建时通过构造函数提供。

public class SimpleSemaphore {
        
        private int signals = 0;
        private int bound = 0;
    
        public SimpleSemaphore(int upperBound) {
        
            this.bound = upperBound;
        }
    }

#### 实现`acquire`方法 ####

`acquire`方法用于获取一个许可。如果当前没有可用的许可（即`signals`等于上界`bound`），那么该方法将阻塞，直到有许可可用。

public synchronized void acquire() throws InterruptedException {
        
        while (signals == bound) {
        
            wait();
        }
        signals++;
        notify();
    }

这里使用`synchronized`关键字来保证方法是线程安全的。如果`signals`达到`bound`，调用`wait()`使当前线程等待，直到`signals`减少后再继续执行。每次调用`acquire`方法时，`signals`都会增加，并且通过`notify()`唤醒可能在等待的线程。

#### 实现`release`方法 ####

`release`方法用于释放一个许可，增加可用许可的数量。如果有线程正在等待许可，那么其中一个线程将被唤醒。

public synchronized void release() throws InterruptedException {
        
        while (signals == 0) wait();
        signals--;
        notify();
    }

同样，使用`synchronized`确保线程安全，并在释放许可后通过`notify()`唤醒可能正在等待的线程。

#### 示例使用 ####

以下是如何使用`SimpleSemaphore`的一个简单示例。

public class Main {
        
        public static void main(String[] args) {
        
            SimpleSemaphore semaphore = new SimpleSemaphore(3); // 允许3个线程同时访问
    
            Runnable longRunningTask = () -> {
        
                try {
        
                    semaphore.acquire();
                    System.out.println("Thread " + Thread.currentThread().getId() + " is running");
                    // 模拟长时间的任务
                    Thread.sleep(2000);
                    semaphore.release();
                    System.out.println("Thread " + Thread.currentThread().getId() + " is finished");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            };
    
            for (int i = 0; i < 10; i++) {
        
                new Thread(longRunningTask).start();
            }
        }
    }

在这个示例中，我们创建了一个具有3个许可的`SimpleSemaphore`，然后启动了10个线程来执行一项长时间运行的任务。由于信号量的限制，这10个线程将分批（每批3个）执行。

#### 总结 ####

通过使用`synchronized`关键字、`wait()`和`notify()`方法，我们可以手动实现一个简单的信号量。这个实现提供了互斥访问和线程间的协调能力。虽然Java的`Semaphore`类提供了更高级的功能，但手动实现信号量是理解并发控制的一个很好的练习。记住，真实环境下应优先使用Java标准库中的并发工具，因为它们经过了更广泛的测试并且优化得更好。