Semaphore(信号量):是一种计数器,用来保护一个或者多个共享资源的访问。如果线程要访问一个资源就必须先获得信号量。如果信号量内部计数器大于0,信号量减1,然后允许共享这个资源;否则,如果信号量的计数器等于0,信号量将会把线程置入休眠直至计数器大于0.当信号量使用完时,必须释放。

实例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
        final Semaphore semaphore = new Semaphore(2);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(new Runnable() {
                public void run() {
                    try {
                        semaphore.acquire();
                        System.out.println("线程:" + Thread.currentThread().getName() + "获得许可:" + index);
                        TimeUnit.SECONDS.sleep(1);
                        semaphore.release();
                        System.out.println("允许TASK个数:" + semaphore.availablePermits()); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        executorService.shutdown();

  构造方法1:

1
2
3
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

  permits 初始许可数,也就是最大访问线程数构造方法2:

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

  permits 初始许可数,也就是最大访问线程数

  fair 当设置为false时,创建的信号量为非公平模式;当设置为true时,信号量是公平模式

主要方法:

  • void acquire() :从信号量获取一个许可,如果无可用许可前将一直阻塞等待,
  • void acquire(int permits) :获取指定数目的许可,如果无可用许可前也将会一直阻塞等待
  • boolean tryAcquire():从信号量尝试获取一个许可,如果无可用许可,直接返回false,不会阻塞
  • boolean tryAcquire(int permits): 尝试获取指定数目的许可,如果无可用许可直接返回false
  • boolean tryAcquire(int permits, long timeout, TimeUnit unit): 在指定的时间内尝试从信号量中获取许可,如果在指定的时间内获取成功,返回true,否则返回false
  • void release(): 释放一个许可,别忘了在finally中使用,注意:多次调用该方法,会使信号量的许可数增加,达到动态扩展的效果,如:初始permits为1, 调用了两次release,最大许可会改变为2
  • int availablePermits(): 获取当前信号量可用的许可

JDK 非公平Semaphore实现:

  1.使用一个参数的构造创建Semaphore对象时,会创建一个NonfairSync对象实例,并将state值设为传入的值(permits ),

1
2
3
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

  NonfairSync间接的继承了AbstractQueuedSynchronizer实现

1
2
3
4
5
6
7
8
9
10
11
final static class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
 
        NonfairSync(int permits) {
            super(permits);
        }
 
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }
1
2
3
4
5
6
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;
 
    Sync(int permits) {
        setState(permits);
    }

  AbstractQueuedSynchronizer 的setState方法

1
2
3
protected final void setState(int newState) {
    state = newState;
}

  2.调用tryAcquire方法时,实际是调用NonfairSync的nonfairTryAcquireShared方法,nonfairTryAcquireShared在父类Sync中实现,

Semaphore# tryAcquire方法:

1
2
3
public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
}

  Sync的nonfairTryAcquireShared方法

1
2
3
4
5
6
7
8
9
final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

  nonfairTryAcquireShared
方法通过获取当前的state,以此state减去需要获取信号量的个数,作为剩余个数,如果结果小于0,返回此剩余的个数;如果结果大于等于0,则基于
CAS将state的值设置为剩余个数,当前步骤用到了for循环,所以只有在结果小于0或设置state值成功的情况下才会退出。如果返回的剩余许可个数大于0,tryAcquire方法则返回true;其余返回false。

  AbstractQueuedSynchronizer的compareAndSetState方法,

1
2
3
4
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

  3.release方法,释放一个许可

1
2
3
public void release() {
    sync.releaseShared(1);
}

  AbstractQueuedSynchronizer的releaseShared方法,

1
2
3
4
5
6
7
public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

  release方法间接的调用了Sync的tryReleaseShared方法,该方法基于Cas 将state的值设置为state+1,一直循环确保CAS操作成功,成功后返回true。

1
2
3
4
5
6
7
protected final boolean tryReleaseShared(int releases) {
    for (;;) {
        int p = getState();
        if (compareAndSetState(p, p + releases))
            return true;
    }
}

  根据上面分析,可以看得出,Semaphore采用了CAS来实现,尽量避免锁的使用,提高了性能

最新文章

  1. spark 问题
  2. [原创.数据可视化系列之二]使用cesium三维地图展示美国全球军事基地分布
  3. runtime之玩转成员变量
  4. CSS水平居中
  5. Dictionary 序列化与反序列化
  6. gdb命令与调试方法
  7. oracle中编写java代码
  8. IIS中使用PUT方法錯誤記錄
  9. itoa : Convert integer to string
  10. Kill Process by Name
  11. java nio io模型
  12. 【已解决】Windows下 MySQL大小写敏感 解决方案及分析
  13. rtx web 分级管理系统 二次开发
  14. SQL SERVER 2019新功能
  15. python3 词法拆分
  16. Vue加载组件、动态加载组件的几种方式
  17. DeviceIoControl 驱动交互
  18. MySql如何安装?
  19. web前端规范
  20. Winform 自定义TabControl实现浏览器标签

热门文章

  1. [设计模式] javascript 之 组合模式
  2. HashMap封装的数据用循环快速添加进list中产生的数据集全部相同的问题
  3. 执行sql失败之后,再次执行的时候提示:ora-02429:无法删除用于强制唯一/主键的索引
  4. Linux 线程--那一年, 我们一起忽视的pthread_join
  5. hdoj 1878 欧拉回路
  6. 核心运营报表无线端数据,pv,uv相关数据,从9月1号开始就没了,为什么?
  7. WordPress插件制作教程概述
  8. HttpWebResponse远程服务器返回错误: (500) 内部服务器错误
  9. jenkins全局安全设置
  10. iOS上机题(附个人见解)
  11. JS中定义对象和集合
  12. Metasploit Framework(4)信息收集
  13. table标签总结
  14. SpringBoot中用Fastjson替换默认的Jackson
  15. treap入门
  16. 推文《阿里凑单算法首次公开!基于Graph Embedding的打包购商品挖掘系统解析》笔记
  17. clearfix 兼容IE6/IE7,解决ie6/ie7下多出一行的问题,bootstrap的clearfix的bug
  18. php导出数组到csv格式demo
  19. PAT——1046. 划拳
  20. js事件委托篇(附js一般写法和js、jq事件委托写法)