码迷,mamicode.com
首页 > 编程语言 > 详细

[笔记][Java7并发编程实战手册]3.2 资源的并发访问控制Semaphore信号量

时间:2015-08-13 23:47:22      阅读:264      评论:0      收藏:0      [点我收藏+]

标签:java   semaphore   并发   多线程   java 7   

[笔记][Java7并发编程实战手册]系列目录


简介

本文学习信号量Semaphore机制。


Semaphore

  1. 本质是一个共享锁
  2. 内部维护一个可用的信号集,获取信号量之前需要先申请获取信号数量;用完之后,则需要释放信号量;如果不释放,那么其他等待线程则一直阻塞直到获取信号量或则被中断为止
  3. 本人的理解是:互斥锁是同一时间只能一个线程访问,而在这里,是同一时间允许获取到了信号量的线程并发访问,而没有获取到信号量的则必须等待信号量的释放;
  4. 将信号量初始化为 1,使得它在使用时最多只有一个可用的许可,从而可用作一个相互排斥的锁。这通常也称为二进制信号量,因为它只能有两种状态:一个可用的许可,或零个可用的许可。按此方式使用时,二进制信号量具有某种属性(与很多 Lock 实现不同),即可以由线程释放“锁”,而不是由所有者(因为信号量没有所有权的概念)。
  5. 同样信号量也分为“公平信号量”和“非公平信号量”,他们的关系就和普通的一致,不过也是包裹了一层“信号量”

下面通过以前的获取苹果的价格的列子来演示信号量的使用

示例1:先来看看上面第3点

public class Client {
    public static void main(String[] args) {
        final GoodInfo gi = new GoodInfo();
        Thread[] read = new Thread[10]; //读线程,读取10次商品信息
        for (int i = 0; i < 10; i++) {
            read[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    gi.getInfo();
                }
            });
        }
        final Thread[] write = new Thread[3]; //写线程,修改3次价格
        for (int i = 0; i < 3; i++) {
            final int finalI = i;
            write[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    gi.setPrice();
                }
            });
        }

        for (Thread t : write) {
            t.start();
        }
        for (Thread t : read) {
            t.start();
        }
    }
}

/** 商品信息类 */
class GoodInfo {
    private String name = "苹果"; //商品名称
    private double price = 10;   //商品价格
    private final Semaphore sh = new Semaphore(3);  //申请3个信号量

    /**
     * 读取商品信息
     *
     * @return
     */
    public void getInfo() {
        try {
            sh.acquire(1); //获取1个信号量,如果不够,则当前线程等待
            String name = this.name;
            double price = this.price;
            System.out.println(Thread.currentThread().getName() + "线程获取了商品信息:" + name + ":" + price);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {  
            sh.release();  //释放信号量
        }
    }

    /**
     * 修改商品价格,每次都自增1
     *
     */
    public void setPrice() {
        try {
            sh.acquire(1);
            this.price = this.price + 1;  //目的是:多个线程并发的时候会出现错误数据(数据竞争来验证获取了信号量的线程是并发线程)
            System.out.println("--------------" + Thread.currentThread().getName() + "线程修改了商品价格:" + name + ":" + price);
            Thread.sleep(20);
        } catch (Exception e) {
            e.printStackTrace();
        } finally { 
            sh.release();  //如果把这里注释掉,则可以看出,其他等待获取信号量的是获取不到信号量了。因为一单这里的三个线程把可用的信号量占用完之后,其他线程就只能等待可用的信号量了
        }
    }
}

某一次的运行结果:

--------------Thread-11线程修改了商品价格:苹果:11.0
Thread-5线程获取了商品信息:苹果:10.0
Thread-7线程获取了商品信息:苹果:11.0
Thread-0线程获取了商品信息:苹果:11.0
Thread-1线程获取了商品信息:苹果:11.0
Thread-2线程获取了商品信息:苹果:11.0
Thread-4线程获取了商品信息:苹果:11.0
Thread-3线程获取了商品信息:苹果:11.0
--------------Thread-10线程修改了商品价格:苹果:12.0
Thread-6线程获取了商品信息:苹果:12.0
--------------Thread-12线程修改了商品价格:苹果:13.0
Thread-8线程获取了商品信息:苹果:13.0
Thread-9线程获取了商品信息:苹果:13.0

如果把写价格的释放信号量注释掉,运行结果是

--------------Thread-12线程修改了商品价格:苹果:11.0
Thread-8线程获取了商品信息:苹果:10.0
Thread-0线程获取了商品信息:苹果:11.0
Thread-4线程获取了商品信息:苹果:11.0
Thread-2线程获取了商品信息:苹果:11.0
Thread-3线程获取了商品信息:苹果:11.0
Thread-1线程获取了商品信息:苹果:11.0
Thread-6线程获取了商品信息:苹果:11.0
Thread-5线程获取了商品信息:苹果:11.0
Thread-7线程获取了商品信息:苹果:11.0
--------------Thread-10线程修改了商品价格:苹果:12.0
--------------Thread-11线程修改了商品价格:苹果:13.0

线程没有运行完,没有获取到信号量的线程,则一直等待。造成了死锁。


说明
上面的运行结果可以看出来:
线程11修改了商品结果,但是线程5和线程11 并发的获取了原有的价格10,导致了线程5获取到了错误的数据信息。

示例2:实现二进制信号量

把以上示例的 构造信号量对象的参数置为1

new Semaphore(1);   /创建二进制信号量

某一次的运行结果是

--------------Thread-10线程修改了商品价格:苹果:11.0
--------------Thread-11线程修改了商品价格:苹果:12.0
Thread-1线程获取了商品信息:苹果:12.0
Thread-2线程获取了商品信息:苹果:12.0
Thread-5线程获取了商品信息:苹果:12.0
Thread-6线程获取了商品信息:苹果:12.0
Thread-9线程获取了商品信息:苹果:12.0
--------------Thread-12线程修改了商品价格:苹果:13.0
Thread-0线程获取了商品信息:苹果:13.0
Thread-4线程获取了商品信息:苹果:13.0
Thread-3线程获取了商品信息:苹果:13.0
Thread-7线程获取了商品信息:苹果:13.0
Thread-8线程获取了商品信息:苹果:13.0

可以看出来,而互斥锁的效果一致。


而这个类的使用场景。我暂时还没想明白。为什么有这样的机制。至于公平信号量和非公平信号量就不演示了。很简单的。知道互斥锁和信号量的区别是什么就行了


另外的acquire方法

  1. acquireUninterruptibly
    其实差不多就是acquire(),底层还是调用了tryAcquireShared(arg)方法,从此信号量中获取许可,在有可用的许可前将其阻塞。
  2. tryAcquire
    尝试过去信号量,能获取就返回true,不能就返回false;从而避开线程阻塞,在使用公平锁的使用要注意此方法。会破坏公平性

版权声明:本文为博主原创文章,未经博主允许不得转载。

[笔记][Java7并发编程实战手册]3.2 资源的并发访问控制Semaphore信号量

标签:java   semaphore   并发   多线程   java 7   

原文地址:http://blog.csdn.net/mr_zhuqiang/article/details/47622621

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!