Java并发编程：信号量（Semaphores，计数信号量，有界信号量，信号量用作锁）

用心去追梦

于 2024-08-15 11:57:59 发布

阅读量428

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/141218861

版权

在Java并发编程中，信号量（Semaphore）是一种非常有用的同步工具，它可以控制对共享资源的访问次数。下面我将详细介绍信号量的概念、类型及其使用方法。

信号量（Semaphore）

定义：
信号量是一种同步工具类，用于控制对共享资源的访问次数。它可以限制同时访问资源的线程数量。

特点：

许可管理：通过许可的数量来控制并发访问。
可重入：线程可以多次获取同一个信号量。
公平性选项：可以设置为公平信号量或非公平信号量。

计数信号量（Counting Semaphore）

定义：
计数信号量是一种信号量，它有一个初始的许可数量。线程可以获取一个许可来访问共享资源，释放资源时返回一个许可。

特点：

许可数量：可以设置信号量的初始许可数量。
获取许可：线程可以获取一个许可来访问共享资源。
释放许可：线程完成访问后释放一个许可。

有界信号量（Bounded Semaphore）

定义：
有界信号量是一种特殊的信号量，它有一个最大许可数量的限制，超过这个数量后不能再增加许可。

特点：

最大许可数量：信号量的许可数量不能超过指定的最大值。
防止资源泄露：避免许可数量无限制地增加。

信号量用作锁

信号量可以用作一种简单的锁机制，特别是当需要控制对共享资源的并发访问次数时。例如，可以使用一个许可数量为1的信号量来模拟互斥锁。

示例

下面是一些使用Semaphore的示例：

计数信号量示例

import java.util.concurrent.Semaphore;

public class CountingSemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // 最多允许3个线程同时访问

    public void accessResource() throws InterruptedException {
        semaphore.acquire(); // 获取一个许可
        try {
            System.out.println(Thread.currentThread().getName() + " is accessing the resource.");
            // 执行资源访问逻辑
        } finally {
            semaphore.release(); // 释放一个许可
        }
    }

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

        for (int i = 0; i < 6; i++) {
            Thread thread = new Thread(() -> {
                try {
                    example.accessResource();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            thread.start();
        }

        Thread.sleep(2000); // 等待一段时间让线程执行
    }
}

在这个示例中，我们创建了一个许可数量为3的信号量semaphore。accessResource方法使用acquire和release方法来控制对共享资源的访问。最多允许3个线程同时访问资源。

有界信号量示例

import java.util.concurrent.Semaphore;

public class BoundedSemaphoreExample {
    private final Semaphore semaphore = new Semaphore(5, true); // 最多允许5个线程同时访问，且是公平的

    public void accessResource() throws InterruptedException {
        semaphore.acquire(); // 获取一个许可
        try {
            System.out.println(Thread.currentThread().getName() + " is accessing the resource.");
            // 执行资源访问逻辑
        } finally {
            semaphore.release(); // 释放一个许可
        }
    }

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

        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                try {
                    example.accessResource();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            thread.start();
        }

        Thread.sleep(2000); // 等待一段时间让线程执行
    }
}

在这个示例中，我们创建了一个许可数量为5的有界信号量semaphore，并且设置为公平信号量。最多允许5个线程同时访问资源，并且线程按请求顺序获取许可。

信号量用作锁示例

import java.util.concurrent.Semaphore;

public class SemaphoreAsLockExample {
    private final Semaphore lock = new Semaphore(1); // 最多允许1个线程同时访问

    public void accessResource() throws InterruptedException {
        lock.acquire(); // 获取一个许可
        try {
            System.out.println(Thread.currentThread().getName() + " is accessing the resource.");
            // 执行资源访问逻辑
        } finally {
            lock.release(); // 释放一个许可
        }
    }

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

        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                try {
                    example.accessResource();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            thread.start();
        }

        Thread.sleep(2000); // 等待一段时间让线程执行
    }
}