Java并发——Semaphore

最新推荐文章于 2023-05-19 10:17:24 发布
最新推荐文章于 2023-05-19 10:17:24 发布
阅读量315 收藏
点赞数 1
分类专栏： 并发编程 文章标签： Java 并发 信号量 Semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cold___play/article/details/106893224
版权

Semaphore

Semaphore即信号、信号系统。此类的主要作用就是限制线程并发的数量，如果不限制线程并发的数量，则CPU的资源很快就被耗尽，每个线程执行的任务是相当缓慢，因为CPU要把时间片分配给不同的线程对象，而且上下文切换也要耗时，最终造成系统运行效率大幅降低，所以限制并发线程的数量还是非常有必要的。

Semaphore的同步性
public class Service {
    private Semaphore semaphore = new Semaphore(1);

    public void testMethod() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + "begin：" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "end:" + System.currentTimeMillis());
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
        ThreadC c = new ThreadC(service);
        c.setName("C");
        c.start();
    }
}

class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}
class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}
class ThreadC extends Thread {
    private Service service;
    public ThreadC(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}

在这里插入图片描述
类Semaphore的构造函数参数permits是许可的意思，代表同一时间内，最多允许多少个线程同时执行acquire()和release()之间的代码。无参方法acquire(的作用是使用1个许可，是减法操作。

其实还可以传人>1的许可，代表同-时间内，最多允许有x个线程可以执行acquire()和release()之间的代码。

acquire(int permits)：
每调用一次方法，就使用permits个许可。

release(int permits)：
每调用一次方法，就增加permits个许可，可以动态增加许可的个数：

Semaphore semaphore = new Semaphore(5);
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        System.out.println(semaphore.availablePermits());
        semaphore.release();
        semaphore.release();
        semaphore.release();
        semaphore.release();
        semaphore.release();
        semaphore.release();
        System.out.println(semaphore.availablePermits());
        semaphore.release(4);
        System.out.println(semaphore.availablePermits());

在这里插入图片描述

acquireUninterruptibly()：
使等待进入acquire()方法的线程，不允许被中断。

public class Service2 {
    private Semaphore semaphore = new Semaphore(1);

    public void test() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + "begin:" + System.currentTimeMillis());
            for (int i = 0; i < Integer.MAX_VALUE / 100; i++) {
                String str = new String();
                Math.random();
            }
            System.out.println(Thread.currentThread().getName() + "end:" + System.currentTimeMillis());
            semaphore.release();
        } catch (InterruptedException e) {
            System.out.println("线程" + Thread.currentThread().getName() + "进入了Catch");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Service2 service2 = new Service2();
        ThreadA a = new ThreadA(service2);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service2);
        b.setName("B");
        b.start();

        b.interrupt();
        System.out.println("main");

    }
}

class ThreadA extends Thread {
    private Service2 service;
    public ThreadA(Service2 service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.test();
    }
}
class ThreadB extends Thread {
    private Service2 service;
    public ThreadB(Service2 service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.test();
    }
}

线程B成功被中断。
在这里插入图片描述
修改acquire方法：
在这里插入图片描述
再次运行效果如下：
在这里插入图片描述
acquireUninterruptibly()方法还有重载的写法acquireUninterruptibly(int permits)，此方法的作用是在等待许可的情况下不允许中断，如果成功获得锁，则取得指定的permits许可个数。

availablePermits()和drainPermits()方法：

availablePermits()返回此Semaphore对象中当前可用的许可数，此方法通常用于调试，因为许可的数量有可能实时在改变，并不是固定的数量。

drainPermits()可获取并返回立即可用的所有许可个数，并且将可用许可置0。

Semaphore semaphore = new Semaphore(10);
        semaphore.acquire();
        System.out.println(semaphore.drainPermits() + " " + semaphore.availablePermits());
        System.out.println(semaphore.drainPermits() + " " + semaphore.availablePermits());
        System.out.println(semaphore.drainPermits() + " " + semaphore.availablePermits());
        semaphore.release();

在这里插入图片描述

getQueueLength()和hasQueuedThreads()：

方法getQueueLength()的作用是取得等待许可的线程个数。

方法hasQueuedThreads()的作用是判断有没有线程在等待这个许可。

这两个方法通常都是在判断当前有没有等待许可的线程信息时使用。

public class MyService {
    private Semaphore semaphore = new Semaphore(1);

    public void test() {
        try {
            semaphore.acquire();
            Thread.sleep(1000);
            System.out.println("还有大约" + semaphore.getQueueLength() + "个线程在等待");
            System.out.println("是否有线程正在等待信号量？" + semaphore.hasQueuedThreads());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        MyService myService = new MyService();

        MyThread firstThread = new MyThread(myService);
        firstThread.start();

        MyThread[] arr = new MyThread[4];
        for (int  i = 0; i < 4; i++) {
            arr[i] = new MyThread(myService);
            arr[i].start();
        }
    }
}

在这里插入图片描述

公平与非公平信号量：

有些时候，获得许可的顺序与线程启动的顺序有关，这时信号量就要分为公平与非公平的。所谓的公平信号量是获得锁的顺序与线程启动的顺序有关，但不代表100%地获得信号量，仅仅是在概率上能得到保证。而非公平信号量就是无关的了。

public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

构造中传入true，即为公平信号量；反之为非公平。公平信号量运行的效果是线程启动的顺序与调用semaphore.acquire()的顺序有关，也就是先启动的线程优先获得许可。

tryAcquire()：
无参方法tryAcquire()的作用是尝试地获得1个许可，如果获取不到则返回false,此方法通常与if语句结合使用，其具有无阻塞的特点。无阻塞的特点可以使线程不至于在同步处一直持续等待的状态，如果if语句判断不成立则线程会继续走else语句，程序会继续向下运行。

tryAcquire(int permits):
有参方法tryAcquire(int permits)的作用是尝试地获得permits个许可，如果获取不到则返回false。

tryAcquire(long timeout, TimeUnit unit)：
有参方法tryAcquire(int long timeout,TimeUnit unit)的作用是在指定的时间内尝试地获得1个许可，如果获取不到则返回false。

tryAcquire(int permits, long timeout, TimeUnit unit)：
有参方法tryAcquire(int permits,long timeout,TimeUnit unit)的作用是在指定的时间内尝试地获得permits个许可，如果获取不到则返回false。

使用Semaphore实现多生产者/多消费者模式
public class RepastService {

    volatile private Semaphore setSemaphore = new Semaphore(10);//10个厨师
    volatile private Semaphore getSemaphore = new Semaphore(20);//食客
    volatile private ReentrantLock lock = new ReentrantLock();
    volatile private Condition setCondition = lock.newCondition();
    volatile private Condition getCondition = lock.newCondition();

    //只有3个盘子放菜品
    volatile private Object[] producePosition = new Object[4];

    private boolean isEmpty() {
        boolean isEmty = true;
        for (int i = 0; i < producePosition.length; i++) {
            if (producePosition[i] != null) {
                isEmty = false;
                break;
            }
        }
        if (isEmty == true) {
            return true;
        } else {
            return false;
        }
    }

    private boolean isFull() {
        boolean isFull = true;
        for (int i = 0; i < producePosition.length; i++) {
            if (producePosition[i] == null) {
                isFull = false;
                break;
            }
        }
        return isFull;
    }

    public void set() {
        try {
            setSemaphore.acquire();//允许同时最多有10个厨师炒菜
            lock.lock();
            while (isFull()) {
                setCondition.await();
            }
            for (int i = 0; i < producePosition.length; i++) {
                if (producePosition[i] == null) {
                    producePosition[i] = "菜";
                    System.out.println(Thread.currentThread().getName() + "生产了" + producePosition[i]);
                    break;
                }
            }
            getCondition.signalAll();
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            setSemaphore.release();
        }
    }

    public void get() {
        try {
            getSemaphore.acquire();//允许同时最多20个食客
            lock.lock();
            while (isEmpty()) {
                getCondition.await();
            }
            for (int i = 0; i < producePosition.length; i++) {
                if (producePosition[i] != null) {
                    System.out.println(Thread.currentThread().getName() + "吃了" + producePosition[i]);
                    producePosition[i] = null;
                    break;
                }
            }
            setCondition.signalAll();
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            getSemaphore.release();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        RepastService service = new RepastService();
        ThreadP[] arrP = new ThreadP[60];
        ThreadC[] arrC = new ThreadC[60];
        for (int i = 0; i < 60; i++) {
            arrP[i] = new ThreadP(service);
            arrC[i] = new ThreadC(service);
        }
        Thread.sleep(2000);
        for (int i = 0; i < 60; i++) {
            arrP[i].start();
            arrC[i].start();
        }
    }
}

//厨师
class ThreadP extends Thread {
    private RepastService service;

    public ThreadP(RepastService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.set();
    }
}

//食客
class ThreadC extends Thread {
    private RepastService service;

    public ThreadC(RepastService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.get();
    }
}

在这里插入图片描述

吴声子夜歌
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程并发（一）Semaphore，volatile，synchronized ，Lock， CyclicBarrier和CountDownLatch
WangShuo的专栏
04-17 3010
在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。我们先看具体看一下这三个概念：1.原子性　　原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。　　 　　一个很经典的例子就是银行账户转账问题 2.可见性　　可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。3.有序性　　有序性
Java并发之Semaphore详解
weixin_34365635的博客
08-09 1321
一、入题 Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二...
Java并发之Semaphore
ArvinWoo
07-17 323
JDK1.5的并发包java.util.concurrent中提供了几个非常有用的工具类，这些工具类给我们在业务开发过程中提供了一种并发流程控制的手段，本文会基于实际应用场景介绍如何使用Semaphore，以及内部实现机制。 Semaphore是什么？ 所谓Semaphore即 信号量 的意思， 这个叫法并不能更好的展示它的作用，更形象的说法应该是许可证管理器。 它可以用来控制同时访问特定资...
并发编程｜说完AQS,面试官为何不淡定了？
热门推荐
09-13 2万+
学完并发编程，还不知道AQS么，赶紧收藏此文，祝你早日拿下面试官，不对，是早日拿到offer
【java并发核心一】Semaphore 的使用思路
09-19 272
1、Semaphore的初步使用 　　Semaphore 是 synchronized 的加强版 作用是: 控制线程的并发数量。就这一点而言，单纯的synchronized 关键字是实现不了的。 package com.cd.concurrent.semaphore; public class MyThread extends Thread { priv...
java 并发编程实践
05-19
本篇文章将深入探讨Java并发编程的相关知识点，主要基于提供的两个文件——"Java并发编程实战（中文版）.pdf"和"Java Concurrency in Practice.pdf"。 1. **线程与并发** - **线程基础**：Java中的线程是并发执行...
java面试——深圳-腾讯-Java高级.zip
09-26
学习synchronized关键字、volatile变量、ThreadLocal、线程池（ExecutorService）以及并发工具类（如Semaphore、CyclicBarrier、CountDownLatch）。理解并发模式如生产者消费者模型，以及线程安全的实现方法。 在...
Java并发编程图册Java并发编程图册
03-29
首先，我们需要理解Java并发编程的基础——线程。在Java中，通过`Thread`类或者实现`Runnable`接口来创建线程。线程是程序执行的最小单位，允许多个任务在同一时间内执行。通过线程，我们可以实现并行处理，提升程序...
Java并发编程之——Amino框架
08-10
Java并发编程是一个复杂而重要的主题，它涉及到多线程、同步机制、线程池和并发容器等关键概念。Amino框架是Java并发编程领域的一个工具，它旨在简化并发编程，提高程序的性能和可维护性。这篇博客文章可能详细探讨...
java acquire()_Java并发核心-semaphore
weixin_39927158的博客
03-04 669
Java并发核心-semaphoreSemaphore 是 synchronized 的加强版，作用是控制线程的并发数量。semaphorepackage com.f.fmodules.fuser.semaphore;public class MyThread extends Thread {private SemaphoreService service;public MyThread(Stri...
java acquire()_Semaphore acquire方法过程实现源代码
weixin_39683692的博客
03-02 516
Semaphore 代码执行的流程，分析acquire的过程信号量在多线程中有着重要的应用，它的原理是将资源抽象成信号量，如果信号量大于0表明有可用资源，小于0，则需要等待。对应申请时，就是做信号量减操作；对应释放时，就是做信号量加操作。资源又抽象成state，这是个所有线程都可见的变量。通过state就可以判断线程是不是可以访问共享资源了。1.new Semaphore()对象时，它调用的 sy...
java并发-Semaphore
最新发布
斜杠码农
05-19 1032
它通过一个计数器来表达可用资源的数量，当有新线程需要访问该资源时，会先进行请求，然后进行P（proberen）操作，如果此时计数器的值为0，则线程就会被阻塞并进入等待队列中，等到其他线程释放资源后才重新获得控制权。本文中介绍了Semaphore的简介、底层实现和应用场景，同时演示了Semaphore在生产消费模型中的实现方式，相信读者可以通过本文进一步熟悉Semaphore的使用方法，从而提高对Java并发编程的理解和实践能力。需要注意的是，一旦线程获取到许可证资源，则许可证数量就会减1。
java多线程工具类_Java多线程同步工具类之Semaphore
weixin_34171095的博客
02-25 115
Semaphore信号量通常做为控制线程并发个数的工具来使用，它可以用来限制同时并发访问资源的线程个数。一、Semaphore使用下面我们通过一个简单的例子来看下Semaphore的具体使用，我们同时执行10个计数线程，并定义一个Semaphore变量用来控制并发值，同一时间只允许两个线程并发执行；public static voidmain(String[] args) {Semaphore s...
Java并发Semaphore
李孟的博客
11-16 513
文章目录一.信号量二.信号量模型三.使用信号量3.1 示例-累加器3.2 示例-限流器 一.信号量 Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。 二.信号量模型 概况为：一个计数器，一个等待队列，三个方法。在信号模型里，计数器和等待队列对外是透明 ，所以只能通过信号模型提供的三个方法来访问它们，这三个方法分别是：init()、down()、up()。 这三个方法详细语
Concurrent - Semaphore - acquireUninterruptibly()
jvisualvm
12-05 556
原创转载请注明出处：http://agilestyle.iteye.com/blog/2342923   acquireUninterruptibly()作用是使等待进入acquire()方法的线程，不允许被中断。 acquireUninterruptibly()还有重载的方法acquireUninterruptibly(int permits)，此方法的作用是在等待permits的情况...
Java多线程相关知识记录
自由空间
03-14 552
1. Semaphore 的 acquire() 方法和acquireUninterruptibly() 方法acquire() 方法是可被中断的。例如一个线程Thread A正在调用了semaphore的acquire() 方法，而另一个线程Thread B 调用interrupt()打断了Thread A , 那么Thread A中则可以抛出一个InterruptedException。而
Semaphore---信号量常用方法总结（1）--Semapore类常用方法--acquire()和acquire(int permits)
weixin_42163781的博客
10-14 2094
Semaphore此类的主要作用是限制线程的并发数量 Semaphore类发放许可的计算方式是“减法”操作 acquire(int permits)作用是每调用一次就使用permits个许可 acquire()作用是每调用一次就使用1个许可 package com.example.demo.ThreadTest.Semaphore; import java.util.concurrent.*; /** *@Description TODO *@Author muyou *@DATE 2020/10
Semaphore类源码解释
baxxdwyp的博客
10-25 149
自己英文比较渣，结合百度翻译，来对Semaphore类的一个解释认识，若有不对的地方请指出。 从头开始 1.创建给定的信号许可证（可以理解为规定的线程数量）和非公平性设置 源码有两个构造，默认就是第一个，也就是实现非公平性 // （一） public Semaphore(int permits) { sync = new NonfairSync(permits); } // （二） pub...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值