多线程开发之Semaphore

Semaphore介绍

Semaphore是java并发编程中出现的一个工具,其具体的作用是用来控制java中对资源的使用。比如我们常用的数据库连接,加入我们希望能够限制同一时间持有数据库连接的数量,我们就可以使用到Semaphore这个工具。

Semaphore介绍

信号量的特性如下:信号量是一个非负整数(车位数),所有通过它的线程(车辆)都会将该整数减一(通过它当然是为了使用资源),当该整数值为零时,所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作: Wait(等待) 和 Release(释放)。 当一个线程调用Wait(等待)操作时,它要么通过然后将信号量减一,要么一直等下去,直到信号量大于一或超时。Release(释放)实际上是在信号量上执行加操作,对应于车辆离开停车场,该操作之所以叫做“释放”是因为加操作实际上是释放了由信号量守护的资源。在这个停车场系统中,车位是公共资源,每辆车好比一个线程,看门人起的就是信号量的作用。

Semaphore主要使用有两个场景

1、与java无界线程池一起使用,来限制线程的到达率
1.1 BounderExecutor.java
public class BounderExecutor {
    private final Executor exec;
    private final Semaphore semaphore;

    public BounderExecutor(Executor exec,int bound){
        this.exec = exec;
        this.semaphore = new Semaphore(bound);
    }

    public void submitTask(final Runnable command)
        throws InterruptedException{
        semaphore.acquire();
        try{
            exec.execute(new Runnable() {

                public void run() {
                    try{
                        command.run();
                    }finally{
                        semaphore.release();
                    }
                }
            });
        }catch(RejectedExecutionException e){
            semaphore.release();
        }
    }
}
1.2 SemaphoreDemo.java
    public static void main(String[] args) {
        BounderExecutor exec = new BounderExecutor(Executors.newCachedThreadPool(), 2);
        Runnable run1 = new Runnable() {
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("r1");
            }
        };
        Runnable run2 = new Runnable() {

            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("r2");
            }
        };
        Runnable run3 = new Runnable() {

            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("r3");
            }
        };
        Runnable run4 = new Runnable() {

            public void run() {
                System.out.println("r4");
            }
        };

        Runnable run5 = new Runnable() {
            public void run() {
                System.out.println("r5");
            }
        };

        try {
            exec.submitTask(run1);
            exec.submitTask(run2);
            exec.submitTask(run3);
            exec.submitTask(run4);
            exec.submitTask(run5);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
1.3 输出结果
r1
r2
r4
r5
r3
无界队列:不能限制队列大小和任务到达率
如果使用Executors.newCachedThreadPool()获得的Exector就是无界的。因为对于线程池来说并不是不断地开辟线程就是最好的,应该适应一定的情况,选择一个适当的大小。对于许多有界队列来说是很好做到的。但是对于那些无界队列,则需要使用到Semaphore。

正如代码中所示的一样,在BounderExecutor.java中,通过构造方法,我们传入Exector和Semaphore的大小。通过构造方法初始化。可以认为Semaphore的大小就是同一时间可以使用资源的数量,也就是开头我们认为车库。acquire方法就是获取一个进入车库的钥匙。而release方法就是讲钥匙还给管理员,由管理员给下一个等待进入车库的车辆。如果没有了车库钥匙,所有的汽车必须等待着。

2、对资源的访问控制
public class MutexPrint  
{  

    /** 
     * 定义初始值为1的信号量 
     */  
    private final Semaphore semaphore = new Semaphore(1);  

    /** 
     * 模拟打印操作 
     * @param str 
     * @throws InterruptedException 
     */  
    public void print(String str) throws InterruptedException  
    {  
        //请求许可  
        semaphore.acquire();  

        System.out.println(Thread.currentThread().getName()+" enter ...");  
        Thread.sleep(1000);  
        System.out.println(Thread.currentThread().getName() + "正在打印 ..." + str);  
        System.out.println(Thread.currentThread().getName()+" out ...");  
        //释放许可  
        semaphore.release();  
    }  

    public static void main(String[] args)  
    {  
        final MutexPrint print = new MutexPrint();  

        /** 
         * 开启10个线程,抢占打印机 
         */  
        for (int i = 0; i < 10; i++)  
        {  
            new Thread()  
            {  
                public void run()  
                {  
                    try  
                    {  
                        print.print("helloworld");  
                    } catch (InterruptedException e)  
                    {  
                        e.printStackTrace();  
                    }  
                };  
            }.start();  
        }  

    }  

}  

输出结果位:

Thread-1 enter ...  
Thread-1正在打印 ...helloworld  
Thread-1 out ...  
Thread-2 enter ...  
Thread-2正在打印 ...helloworld  
Thread-2 out ...  
Thread-0 enter ...  
Thread-0正在打印 ...helloworld  
Thread-0 out ...  
Thread-3 enter ...  
Thread-3正在打印 ...helloworld  
Thread-3 out ...  
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值