首页 > 编程语言 >详解Java信号量-Semaphore

详解Java信号量-Semaphore

时间：2024-01-13 15:02:27浏览次数：38  
标签：Java 许可 Thread semaphore 信号量 线程 Semaphore new

第1章：引言

大家好，我是小黑。今天，咱们一起来深入探讨一下Semaphore。在Java中，正确地管理并发是一件既挑战又有趣的事情。当谈到并发控制，大家可能首先想到的是synchronized关键字或者是ReentrantLock。但其实，Java还提供了一个非常强大的工具，就是Semaphore。

Semaphore，直译过来就是“信号量”。在日常生活中，信号灯控制着车辆的通行，防止交通混乱，这其实和Semaphore在程序中的作用颇为相似。Semaphore主要用于控制同时访问特定资源的线程数量，它通过协调各个线程，保证合理的使用公共资源。比方说如果有一家餐馆只允许固定数量的顾客同时用餐，这就是Semaphore的经典应用场景。

第2章：Semaphore的基本概念

让我们先来了解一下Semaphore的基本概念。在Java中，Semaphore是位于java.util.concurrent包下的一个类。它的核心就是维护了一个许可集。简单来说，就是有一定数量的许可，线程需要先获取到许可，才能执行，执行完毕后再释放许可。

那么，这个许可是什么呢？其实，你可以把它想象成是对资源的访问权。比如，有5个许可，就意味着最多允许5个线程同时执行。线程可以通过acquire()方法来获取许可，如果没有可用的许可，该线程就会阻塞，直到有许可可用。

让我们看个简单的例子。假设咱们有一个限制了最多同时3个线程执行的Semaphore：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    // 创建一个Semaphore实例，许可数量为3
    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        // 创建并启动三个线程
        for (int i = 1; i <= 3; i++) {
            new Thread(new Task(semaphore), "线程" + i).start();
        }
    }

    static class Task implements Runnable {
        private final Semaphore semaphore;

        public Task(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                // 请求许可
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 获取许可，正在执行");
                Thread.sleep(1000); // 模拟任务执行
                System.out.println(Thread.currentThread().getName() + " 执行完毕，释放许可");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 释放许可
                semaphore.release();
            }
        }
    }
}

在这个例子中，咱们创建了一个Semaphore实例，设置最大许可数为3。这意味着，最多只能有3个线程同时运行Task中的代码。每个线程在开始执行前，都会尝试通过acquire()方法获取一个许可。

第3章：Semaphore的核心原理

现在，咱们深入一下Semaphore的核心原理。理解这个原理对于掌握Semaphore的高效使用至关重要。在Java中，Semaphore不仅仅是个计数器，它背后的原理和实现逻辑比看起来要复杂得多。

Semaphore的核心是基于AQS（AbstractQueuedSynchronizer）这个框架。AQS是Java并发包中的一个非常重要的组件，它用来构建锁或者其他同步器。简单来说，AQS提供了一种机制，可以让线程在访问某个资源前进入等待状态，并在资源可用时被唤醒。这正是Semaphore的基础。

Semaphore维护了一个许可集，这个集合的大小在初始化时设定。每次调用acquire()方法，Semaphore会试图从这个集合中取出一个许可。如果没有可用的许可，线程就会被阻塞，直到有其他线程释放一个许可。相反，release()方法会增加许可的数量，并有可能唤醒等待的线程。

让小黑通过一段代码来更好地说明这个原理：

import java.util.concurrent.Semaphore;

public class SemaphoreDeepDive {
    public static void main(String[] args) {
        // 初始化一个只有2个许可的Semaphore
        Semaphore semaphore = new Semaphore(2);

        Runnable task = () -> {
            try {
                // 尝试获取许可
                semaphore.acquire();
                System.out.println("线程 " + Thread.currentThread().getName() + " 获取了许可");
                // 模拟任务执行
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 释放许可
                semaphore.release();
                System.out.println("线程 " + Thread.currentThread().getName() + " 释放了许可");
            }
        };

        // 创建并启动3个线程
        for (int i = 0; i < 3; i++) {
            new Thread(task).start();
        }
    }
}

在这个例子中，Semaphore被初始化为只有两个许可。当三个线程尝试运行时，只有两个能够同时执行。第三个线程必须等待，直到一个许可被释放。这就是Semaphore控制并发的机制。

第4章：使用Semaphore的场景

咱们来聊聊Semaphore在实际编程中的应用场景。理解了Semaphore的基础和原理后，咱们现在可以探索它在实际场景中的具体使用。Semaphore非常灵活，可以用于多种场合，特别是在控制资源访问的并发环境中。

场景一：资源池

想象一下，小黑有一个数据库连接池，这个池子里只有几个数据库连接。如果所有的连接都被占用了，其他需要数据库连接的线程就得等待。这就是Semaphore的经典应用场景。通过限制可用的连接数量，Semaphore确保了不会有太多的线程同时访问数据库。

场景二：限流

在Web服务中，咱们可能想要限制某个服务的并发请求数量，以防止服务器过载。Semaphore可以很容易地实现这个功能。设置一个固定数量的许可，就可以限制同时处理的请求数量。

代码示例

让小黑用代码展示一下这些场景。首先，是一个简单的数据库连接池的示例：

import java.util.concurrent.Semaphore;

public class DatabaseConnectionPool {
    private final Semaphore semaphore;
    private final String[] connectionPool;
    private final boolean[] used;

    public DatabaseConnectionPool(int poolSize) {
        semaphore = new Semaphore(poolSize);
        connectionPool = new String[poolSize];
        used = new boolean[poolSize];
        for (int i = 0; i < poolSize; i++) {
            connectionPool[i] = "连接 " + (i + 1);
        }
    }

    public String getConnection() throws InterruptedException {
        semaphore.acquire();
        return getNextAvailableConnection();
    }

    public void releaseConnection(String connection) {
        if (markAsUnused(connection)) {
            semaphore.release();
        }
    }

    private synchronized String getNextAvailableConnection() {
        for (int i = 0; i < connectionPool.length; i++) {
            if (!used[i]) {
                used[i] = true;
                return connectionPool[i];
            }
        }
        return null; // 不应该发生，semaphore保证了有可用连接
    }

    private synchronized boolean markAsUnused(String connection) {
        for (int i = 0; i < connectionPool.length; i++) {
            if (connection.equals(connectionPool[i])) {
                used[i] = false;
                return true;
            }
        }
        return false;
    }
}

这个代码演示了如何使用Semaphore来控制对有限数量资源（数据库连接）的访问。每个连接在使用前需要获得一个许可，使用完后释放许可。

第5章：Semaphore的高级特性

公平性与非公平性

Semaphore有两种模式：公平模式和非公平模式。公平模式下，线程获得许可的顺序与它们请求许可的顺序一致，就像排队一样。而非公平模式则没有这种保证，线程可以“插队”，这可能会导致某些线程等待时间过长。

在Java中，创建Semaphore时可以指定是公平模式还是非公平模式。默认情况下，Semaphore是非公平的。公平模式通常会有更高的性能开销，因为它需要维护一个更加复杂的内部结构来保证顺序。

可中断操作

在Semaphore中，等待许可的操作可以是可中断的。这意味着如果一个线程在等待一个许可时被中断，它可以选择退出等待。这在处理某些需要响应中断的场景时非常有用。

代码示例

让小黑给你演示一下这两个特性的代码实例：

import java.util.concurrent.Semaphore;

public class SemaphoreAdvancedFeatures {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个公平模式的Semaphore
        Semaphore fairSemaphore = new Semaphore(1, true);

        // 创建并启动两个线程
        Thread t1 = new Thread(new Worker(fairSemaphore), "线程1");
        Thread t2 = new Thread(new Worker(fairSemaphore), "线程2");
        t1.start();
        t2.start();

        // 演示可中断操作
        Thread interruptibleThread = new Thread(() -> {
            try {
                fairSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 获取了许可");
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 被中断");
            }
        });
        interruptibleThread.start();
        Thread.sleep(1000); // 等待一会
        interruptibleThread.interrupt(); // 中断线程
    }

    static class Worker implements Runnable {
        private final Semaphore semaphore;

        Worker(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 获取了许可");
                Thread.sleep(2000); // 模拟工作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                semaphore.release();
                System.out.println(Thread.currentThread().getName() + " 释放了许可");
            }
        }
    }
}

在这个代码中，小黑创建了一个公平模式的Semaphore，并演示了两个线程按顺序获取许可的情况。同时，还展示了一个线程在尝试获取许可时如何被中断。

第6章：Semaphore的问题与解决方案

问题一：资源耗尽

最常见的问题之一是资源耗尽。当所有许可都被占用，并且持有许可的线程因某种原因无法释放许可时，就会出现资源耗尽的情况。这可能会导致其他线程永久等待，从而造成死锁。

解决方案：确保在使用资源后总是释放许可。可以使用try-finally块来确保即使在发生异常时也能释放许可。

问题二：公平性问题

如前所述，Semaphore可以是公平的或非公平的。在非公平模式下，有可能导致某些线程饥饿，即永远得不到执行的机会。

解决方案：如果需要保证每个线程都有机会执行，可以考虑使用公平模式的Semaphore。

问题三：性能问题

在高并发场景中，Semaphore可能成为性能瓶颈。由于线程频繁地获取和释放许可，可能会导致过多的上下文切换和竞争。

解决方案：适当调整许可的数量，或者寻找其他更适合高并发场景的并发工具。

代码示例

让小黑通过代码来展示如何妥善处理这些问题：

import java.util.concurrent.Semaphore;

public class SemaphoreProblemSolving {
    private static final Semaphore semaphore = new Semaphore(1);

    public static void main(String[] args) {
        Thread thread1 = new Thread(SemaphoreProblemSolving::safeMethod, "线程1");
        Thread thread2 = new Thread(SemaphoreProblemSolving::safeMethod, "线程2");

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

    private static void safeMethod() {
        try {
            semaphore.acquire();
            try {
                // 执行关键区域代码
                System.out.println(Thread.currentThread().getName() + " 在执行");
                Thread.sleep(1000);
            } finally {
                semaphore.release(); // 确保总是释放许可
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这段代码中，小黑展示了如何使用try-finally块来确保无论如何都会释放Semaphore的许可。这种方式可以减少由于异常导致的资源耗尽问题。

第7章：与其他并发工具的结合使用

结合CountDownLatch

CountDownLatch是一种同步帮助，它允许一个或多个线程等待其他线程完成一系列操作。在某些场景中，咱们可能需要先用Semaphore控制资源访问，然后使用CountDownLatch来同步多个线程的进度。

结合CyclicBarrier

CyclicBarrier与CountDownLatch类似，但它允许一组线程相互等待，达到一个共同的障碍点再继续执行。这在需要多个线程在某个点同步执行的场景中非常有用。结合Semaphore，可以在达到共同点之前控制线程对资源的访问。

代码示例

让小黑给咱们展示一个结合使用Semaphore和CountDownLatch的例子：

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

public class CombinedSemaphoreCountDownLatch {
    private static final int THREAD_COUNT = 5;
    private static final Semaphore semaphore = new Semaphore(2);
    private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Worker(i, semaphore, latch)).start();
        }
        latch.await();  // 等待所有线程完成
        System.out.println("所有线程执行完毕");
    }

    static class Worker implements Runnable {
        private final int workerNumber;
        private final Semaphore semaphore;
        private final CountDownLatch latch;

        Worker(int workerNumber, Semaphore semaphore, CountDownLatch latch) {
            this.workerNumber = workerNumber;
            this.semaphore = semaphore;
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人 " + workerNumber + " 正在工作");
                Thread.sleep(1000); // 模拟工作
                semaphore.release();
                latch.countDown(); // 完成工作，计数减一
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

在这个例子中，小黑创建了一个包含5个线程的场景。使用Semaphore来控制同时工作的线程数量，同时使用CountDownLatch来确保所有线程都完成工作后主线程才继续执行。

第8章：总结

  • 基本概念：Semaphore是一种基于计数的同步工具，用于控制同时访问特定资源的线程数量。
  • 原理理解：Semaphore的实现依赖于AQS（AbstractQueuedSynchronizer），提供了一种机制来管理和控制线程的访问。
  • 实际应用：从资源池管理到限流控制，Semaphore在多种场景中都非常有用。
  • 高级特性：包括公平性和非公平性的选择，以及对线程中断的响应。
  • 问题解决：面对资源耗尽和性能问题，咱们学习了如何妥善处理Semaphore带来的挑战。
  • 与其他工具结合：Semaphore能与CountDownLatch、CyclicBarrier等并发工具结合使用，解决更复杂的并发问题。

标签：Java,许可,Thread,semaphore,信号量,线程,Semaphore,new
From： https://blog.51cto.com/u_16326109/9232476

相关文章

  • JavaScript学习之旅——初识
    JavaScript学习之旅——初识本文内容基于JavaScript相关基础知识进行介绍JavaScript学习之旅——初识前言一、JavaScript是什么（都有什么呢？）1.ECMAScript2.WebAPIs二、JavaScript的书写位置1.内部JavaScript2.外部JavaScript3.内联（行内）JavaScript4.JavaScript语句结束符三、......
  • 【Linux】Java文件IO之普通IO与Buffer IO
    在Java中，输入输出（IO）操作是编程中一项重要的任务。无论是从外部文件中读取数据，还是向文件写入数据，或者是与用户进行交互，都需要用到IO操作。普通IOFileOutputStream的使用FileOutputStream是Java中的一个类，属于java.io包。它用于将数据写入文件。当你需要将数据（通常是字节或字符）写入......
  • 【flink番外篇】9、Flink Table API 支持的操作示例（14）- 时态表的join（java版本）
    文章目录Flink系列文章一、maven依赖二、时态表的join1、统计需求对应的SQL2、Withoutconnnector实现代码3、Withconnnector实现代码1）、bean定义2）、序列化定义3）、实现本文通过两个示例介绍了时态表TemporalTableFunction的join操作。本文除了maven依赖外，没有其他依赖。一、m......
  • Invalid value type for attribute ‘factoryBeanObjectType‘: java.lang.String
    ErrorstartingApplicationContext.Todisplaytheconditionevaluationreportre-runyourapplicationwith'debug'enabled.2024-01-05T17:04:00.527+08:00ERROR201118---[solve][main]o.s.boot.SpringApplication:Appli......
  • 《Java编程思想第四版》学习笔记53--关于UDP
    1、TCP和UDP端口是相互独立的。也就是说，可以在端口8080同时运行一个TCP和UDP服务程序，两者之间不会产生冲突。P.547//:Dgram.java//Autilityclasstoconvertbackandforth//BetweenStringsandDataGramPackets.importjava.net.*;publicclassDgram{publ......
  • Java日期时间处理详解
    Java中SimpleDateFormat、LocalDateTime和DateTimeFormatter的区别及使用在Java的世界里，处理日期和时间是常见的任务。尤其在Java8之前，SimpleDateFormat是处理日期和时间的主要方式。然而，Java8引入了新的日期时间API，其中LocalDateTime和DateTimeFormatter成为了新的选择。本文......
  • 详解Java多线程之循环栅栏技术CyclicBarrier
    第1章：引言大家好，我是小黑，工作中，咱们经常会遇到需要多个线程协同工作的情况。CyclicBarrier，直译过来就是“循环屏障”。它是Java中用于管理一组线程，并让它们在某个点上同步的工具。简单来说，咱们可以把一群线程想象成一队马拉雪橇的驯鹿，CyclicBarrier就像是一个指定的集合点，所有驯......
  • java项目(jar包)配置为开机自启 jar包bat脚本启动和配置为开机自启
    今天给大家分享一下，如何把java项目，打包--------打包后启动---------生成bat文件启动-----------设置为开机自启。每一步都是先是文字描述，后面是图片展示。首先是打包，咱们写好的项目在maven处点击clear，等待完成后，点击package      打包完成后，在target目录下可以看到......
  • Java中锁的解决方案
    前言在上一篇文章中，介绍了什么是锁，以及锁的使用场景，本文继续给大家继续做深入的介绍，介绍JAVA为我们提供的不同种类的锁。JAVA为我们提供了种类丰富的锁，每种锁都有不同的特性，锁的使用场景也各不相同。由于篇幅有限，在这里只给大家介绍比较常用的几种锁。我会通过锁的定义，核心代码......
  • Java学习之路1
    下载JDK了解Java的运行过程 知道javac的作用是将java文件编译成class文件为了方便多平台同运算了解cmd是GBK编译代码JDK是utf-8编译代码这会导致某些地方代码运行不是自己想要的结果编译运行第一个代码helloworld在运行之后的println中又了解到JDK8和JKD11的区别......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99