详解Java信号量-Semaphore

这篇具有很好参考价值的文章主要介绍了详解Java信号量-Semaphore。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

java semaphore,Java多线程高并发编程实战,java,并发,多线程

java semaphore,Java多线程高并发编程实战,java,并发,多线程

第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();
            }
        }
    }
}

java semaphore,Java多线程高并发编程实战,java,并发,多线程

在这个例子中,咱们创建了一个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();
        }
    }
}

java semaphore,Java多线程高并发编程实战,java,并发,多线程

在这个例子中,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

CyclicBarrierCountDownLatch类似,但它允许一组线程相互等待,达到一个共同的障碍点再继续执行。这在需要多个线程在某个点同步执行的场景中非常有用。结合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来确保所有线程都完成工作后主线程才继续执行。文章来源地址https://www.toymoban.com/news/detail-857909.html

第8章:总结

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

到了这里,关于详解Java信号量-Semaphore的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 『Linux』第九讲:Linux多线程详解(五)_ 信号量

    「前言」文章是关于Linux多线程方面的知识,上一篇是 Linux多线程详解(四),今天这篇是 Linux多线程详解(五),内容大致是信号量,讲解下面开始! 「归属专栏」Linux系统编程 「主页链接」个人主页 「笔者」枫叶先生(fy) 「枫叶先生有点文青病」「每篇一句」 求其上,

    2024年02月07日
    浏览(49)
  • 【Linux C | 多线程编程】线程同步 | 信号量(无名信号量) 及其使用例子

    😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀 🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭 🤣本文内容🤣:🍭介绍 🍭 😎金句分享😎:🍭你不能选择最好的,但最好的会来选择你——泰戈尔🍭 ⏰发布时间⏰: 本文未经允许,不得转发!!!

    2024年04月26日
    浏览(37)
  • 并发编程 --- 信号量线程同步

    上文编码技巧 --- 同步锁对象的选定中,提到了在C#中,让线程同步有两种方式: 锁(lock、Monitor等) 信号量(EventWaitHandle、Semaphore、Mutex) 加锁是最常用的线程同步的方法,就不再讨论,本篇主要讨论使用信号量同步线程。 实际上,再C#中 EventWaitHandle 、 Semaphore 、 Mutex 都是

    2024年02月16日
    浏览(41)
  • 线程同步-信号量-互斥量-条件变量

    线程同步其实实现的是线程排队。 防止线程同步访问共享资源造成冲突。 多个线程访问共享资源的代码有可能是同一份代码,也有可能是不同的代码;无论是否执行同一份代码,只要这些线程的代码访问同一份可变的共享资源,这些线程之间就需要同步。 1. 问题 同一个进程

    2023年04月16日
    浏览(36)
  • C多线程、锁、同步、信号量

    1.1 创建线程 thread 是线程变量地址 attr是线程属性,一般为NULL start_rount 是函数指针 arg 是函数指针指向函数的参数 1.2 线程退出 retval可以把退出值带回去,例子见线程回收 1.3 线程回收 1.4 线程分离: 某些情况下,程序的主线程有自己的其他业务,如果让主线程负责子线程的

    2024年02月02日
    浏览(73)
  • 【Linux】多线程 之 POSIX信号量

    信号量又称为 信号灯 本质就是一个计数器,用于描述临界资源数目的 sem: 0 - 1 - 0 若临界资源只有1个,则sem设为1,当要使用临界资源时,sem由1变为0,其他人在想申请,则申请不到挂起排队,等待释放临界资源时 sem由0变为1 ,才可以再申请临界资源 这种信号量称为 二元信号

    2024年02月16日
    浏览(46)
  • iOS信号量造成线程优先级反转

    在并发队列使用信号量会可能会造成线程优先级反转 经过查询资料,发现是在XCode14上增加了工具,比如 : Thread Performance Checker (XCode14上默认开启的),这个工具会让APP在运行的时候,发现有例如线程优先级反转和非UI工作在主线程上运行等问题的时候,就会在XCode问题导航

    2024年02月05日
    浏览(37)
  • 一文搞定Linux线程间通讯 / 线程同步方式-互斥锁、读写锁、自旋锁、信号量、条件变量、信号等等

    目录 线程间通讯 / 线程同步方式 锁机制 互斥锁(Mutex) 读写锁(rwlock) 自旋锁(spin) 信号量机制(Semaphore) 条件变量机制 信号(Signal) 线程间通讯 / 线程同步方式 p.s 以下有很多段落是直接引用,没有使用 markdown 的 “引用” 格式,出处均已放出。 参考 / 引用: 100as

    2024年02月10日
    浏览(41)
  • 线程同步、生产者消费模型和POSIX信号量

    gitee仓库: 1.阻塞队列代码:https://gitee.com/WangZihao64/linux/tree/master/BlockQueue 2.环形队列代码:https://gitee.com/WangZihao64/linux/tree/master/ringqueue 概念 : 利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待\\\"条件变量的条件成立\\\"而挂起;另一个线程使“

    2024年02月03日
    浏览(46)
  • 【系统编程】线程安全(POSIX信号量、互斥锁、读写锁等)

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,数据结构,Linux基础,ARM开发板,网络编程等领域UP🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,请在评论区指

    2024年02月10日
    浏览(62)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包