`

Concurrent - Semaphore - acquire(int permits)

 
阅读更多

原创转载请注明出处:http://agilestyle.iteye.com/blog/2342898

 

有参方法acquire(int permits)表示每调用1次此方法,就使用Semaphore中的x个permits



Service.java

package org.fool.java.concurrent.semaphore.acquire;

import java.util.concurrent.Semaphore;

public class Service {
    private Semaphore semaphore = new Semaphore(10);

    public void testMethod() {
        try {
            semaphore.acquire(2);

            System.out.println(Thread.currentThread().getName() + " begin timer=" + System.currentTimeMillis());

            int sleepValue = 5000;
            System.out.println(Thread.currentThread().getName() + " stop " + (sleepValue / 1000) + " sec");
            Thread.sleep(sleepValue);

            System.out.println(Thread.currentThread().getName() + " end timer=" + System.currentTimeMillis());

            semaphore.release(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Note:

private Semaphore semaphore = new Semaphore(10);

定义10个permits,每次执行semaphore.acquire(2);消耗掉2个,所以10/2=5,说明同一时间只允许5个线程执行acquire()和release()之间的代码。 

ThreadA.java

package org.fool.java.concurrent.semaphore.acquire;

public class ThreadA implements Runnable {
    private Service service;

    public ThreadA(Service service) {
        this.service = service;
    }

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

SemaphoreTest.java

package org.fool.java.concurrent.semaphore.acquire;

public class SemaphoreTest {
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        for (int i = 0; i < 10; i++) {
            new Thread(new ThreadA(service)).start();
        }
    }
}

Run


 

如果多次调用Semaphore的release()或release(int)方法时,还可以动态增加permits的个数。

package org.fool.java.concurrent.semaphore.acquire;

import java.util.concurrent.Semaphore;

public class SemaphoreTest2 {
    public static void main(String[] args) {
        try {
            Semaphore semaphore = new Semaphore(5);

            semaphore.acquire();
            semaphore.acquire();
            semaphore.acquire();
            semaphore.acquire();
            semaphore.acquire();

            System.out.println(semaphore.availablePermits());   // outputs 0

            semaphore.release();
            semaphore.release();
            semaphore.release();
            semaphore.release();
            semaphore.release();
            semaphore.release();

            System.out.println(semaphore.availablePermits());   // outputs 6

            semaphore.release(4);

            System.out.println(semaphore.availablePermits());   // outputs 10
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

Note:

Semaphore semaphore = new Semaphore(5);

 定义的5并不是最终的permits数量,仅仅是初始的状态值。

 

 

 

 

  • 大小: 49.1 KB
  • 大小: 13.6 KB
分享到:
评论

相关推荐

    通俗易懂学习java并发工具类-Semaphore,Exchanger

    【Semaphore详解】Semaphore是Java并发包`java.util.concurrent`中的一个工具类,它主要用于控制并发访问的线程数量。Semaphore可以被理解为一种资源的许可证,每个许可证代表了一个可访问的资源实例。线程在执行前...

    JAVA多线程--信号量(Semaphore)_.docx

    Semaphore(int permits, boolean fair) ``` 创 建 具 有 给 定 的 许 可 数 和 给 定 的 公 正 设 置 的Semaphore。 Semaphore当前在多线程环境下被扩放用法,操作系统的信号量是个很重要的概念,在进程掌握方面都...

    Java进程信号量机制的实验程序

    - `Semaphore(int permits)`构造函数初始化信号量,参数`permits`表示初始的许可数量。 - `acquire()`方法用于获取一个许可,如果当前许可数量大于零,则消耗一个许可,否则线程被阻塞等待。 - `acquire(int ...

    Java 信号量编程实践

    2. `Semaphore(int permits, boolean fair)`:创建具有指定初始许可数的信号量,并可以选择是否采用公平策略。公平策略意味着等待时间最长的线程将优先获取许可,而不公平策略则没有这样的保证。 **二、Semaphore的...

    Java并发编程之Semaphore(信号量)详解及实例

    2. `Semaphore(int permits, boolean fair)`: 创建具有给定许可数的公平(true)或非公平(false)Semaphore。 Semaphore 的方法 1. `acquire()`: 从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则...

    并发编程之Tools&CountDownLatch&Semaphore原理与应用1

    2. `Semaphore(int permits, boolean fair)`:除了指定许可数量外,还可以设置是否启用公平策略。公平策略意味着等待最长时间的线程优先获得许可。 Semaphore提供以下核心方法: 1. `void acquire()`:获取一个...

    Java并发编程(23)并发新特性-信号量Semaphor

    在Java 5引入并发包`java.util.concurrent`后,信号量作为`Semaphore`类被添加,成为并发编程的一个新特性。 信号量的核心概念是许可(permits),它可以看作是系统中可用资源的数量。当一个线程想要访问公共资源时...

    Java基于Semaphore构建阻塞对象池

    1. `Semaphore(int permits)`:默认是非公平策略,创建一个具有指定许可数量的Semaphore。 2. `Semaphore(int permits, boolean fair)`:允许指定是否采用公平策略。公平策略意味着按照线程等待的顺序分配许可,而非...

    JAVA 多线程之信号量(Semaphore)实例详解

    Semaphore(int permits, boolean fair) // 创建指定数量的许可证的信号量,并指定是否为公平模式 ``` ### 代码示例 下面是一个简单的Semaphore使用示例,模拟了5个资源(停车位)供20个线程(车辆)共享的情况: ...

    米哈游笔试题目-Java方向.docx

    this.semaphore = new Semaphore(permits); } public void acquire() throws InterruptedException { semaphore.acquire(); } public void release() { semaphore.release(); } } ``` ### 分布式锁类 ##...

    SOI-ThreadsSemaphore-I

    在Java编程语言中,`Semaphore`是一个非常重要的同步工具类,它源于`java.util.concurrent`包,用于控制同时访问特定资源的线程数量。标题"SOI-ThreadsSemaphore-I"暗示了这个项目或教程可能专注于如何在多线程环境...

    Java并发编程:CountDownLatch与CyclicBarrier和Semaphore的实例详解

    public Semaphore(int permits);//参数permits表示可用的许可数 Semaphore类中最重要的三个方法是: 1. public void acquire() throws InterruptedException {}; //获得一个许可 2. public boolean tryAcquire() ...

    semaphores:一个简单的信号量程序,显示当多个线程尝试同时访问代码的关键部分时如何互斥

    5. `tryAcquire(int permits)`: 尝试获取指定数量的许可证。如果足够数量的许可证可用,立即返回true;否则,返回false。 在实际应用中,信号量常用于限制线程池大小、保护临界区或实现线程之间的协作。例如,在一...

Global site tag (gtag.js) - Google Analytics