semphore源码分析
目录
1:semphore的使用说明
参考这篇博客:https://www.cnblogs.com/crazymakercircle/p/13907012.html
2:semphore的使用案例
package com.saytoyou.com.thread; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class Student implements Runnable { private String studentName; private Semaphore semaphore; /** * 学生构造函数 * * @param studentName * @param semaphore */ public Student(String studentName, Semaphore semaphore) { this.studentName = studentName; this.semaphore = semaphore; } @Override public void run() { try { semaphore.acquire(); System.out.println("我是"+studentName+"开始排队"); System.out.println("我是"+studentName + "开始打饭了" ); TimeUnit.SECONDS.sleep(3); } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("打饭完成" + studentName); semaphore.release(); } } }
package com.saytoyou.com.thread; import java.util.concurrent.Semaphore; public class SemaphoreTest { public static void main(String[] args) { //模拟学生食堂打饭,设置三个窗口同时执行 Semaphore semaphore = new Semaphore(3,true); for (int i = 0; i < 100; i++) { new Thread(new Student("学生" + i, semaphore)).start(); } } }
3:semphore的源码分析
3.1:构造函数分析
public Semaphore(int permits, boolean fair) { sync = fair ? new FairSync(permits) : new NonfairSync(permits); }
构造semphore,permits是线程的个数,fair设置公平锁和非公平锁
3.2:acquire方法源码分析
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException { final Node node = addWaiter(Node.SHARED); boolean failed = true; try { for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) throw new InterruptedException(); } } finally { if (failed) cancelAcquire(node); } }
分析:
1:首先将节点放入等待队列中,返回当前节点,注意第一次的头节点是new空节点,不是当前节点
2:拿到当前节点的前驱节点,判断前驱节点是否为头节点,如果为头节点则尝试去获取资源,获取成功当前state减一,返回剩余state,并尝试唤醒后续节点
如果不是头节点,则放入FIFO阻塞队列,等待后续唤醒
3:加入state的初始值为3,那么前三个线程都可以进入获取资源,后面的就需要等待线程释放,唤醒
4:第一次node节点进入,head是新节点,指向第一个节点,第二个节点跟这进来,状态改为signal,第三个节点同上,第一个节点进入后获取资源并唤醒第二个,第二个把头介点设置为自己,接着唤醒第三个,后面stagte资源不足了,就需要不断循环尝试获取了
3.3:tryAcquireShared源码分析
final int nonfairTryAcquireShared(int acquires) { for (;;) { int available = getState(); int remaining = available - acquires; if (remaining < 0 || compareAndSetState(available, remaining)) return remaining; } }
分析:获取当前state的值,拿当前的state减去请求数,一般都是1,重新设置state的值,返回state的最新值
结合上面的分析为:进来之后进入阻塞队列中,判断节点的前驱节点是不是head如果是,就尝试获取资源,获取成功之后,唤醒后续节点
流程图如下:
4:释放资源源码分析
protected final boolean tryReleaseShared(int releases) { for (;;) { int current = getState(); int next = current + releases; if (next < current) // overflow throw new Error("Maximum permit count exceeded"); if (compareAndSetState(current, next)) return true; } }
释放资源,state的值加一,这样后续第四个线程被唤醒,其实是第一个线程释放state,然后唤醒第四个线程的
4.1 唤醒后续的等待线程
private void doReleaseShared() { for (;;) { Node h = head; if (h != null && h != tail) { int ws = h.waitStatus; if (ws == Node.SIGNAL) { if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) continue; // loop to recheck cases unparkSuccessor(h); } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) continue; // loop on failed CAS } if (h == head) // loop if head changed break; } }
此时head是指向第三个线程的,状态为signal,唤醒后一个线程