java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能
**这是java高并发系列第15篇文章 **html
Semaphore（信号量）为多线程协做提供了更为强大的控制方法，前面的文章中咱们学了synchronized和重入锁ReentrantLock，这2种锁一次都只能容许一个线程访问一个资源，而信号量能够控制有多少个线程能够同时访问特定的资源。java
Semaphore经常使用场景：限流安全
举个例子：微信
好比有个停车场，有5个空位，门口有个门卫，手中5把钥匙分别对应5个车位上面的锁，来一辆车，门卫会给司机一把钥匙，而后进去找到对应的车位停下来，出去的时候司机将钥匙归还给门卫。停车场生意比较好，同时来了100两车，门卫手中只有5把钥匙，同时只能放5辆车进入，其余车只能等待，等有人将钥匙归还给门卫以后，才能让其余车辆进入。多线程
上面的例子中门卫就至关于Semaphore，车钥匙就至关于许可证，车就至关于线程。并发
Semaphore主要方法
-
Semaphore(int permits)：构造方法，参数表示许可证数量，用来建立信号量异步
-
Semaphore(int permits,boolean fair)：构造方法，当fair等于true时，建立具备给定许可数的计数信号量并设置为公平信号量分布式
-
void acquire() throws InterruptedException：今后信号量获取1个许可前线程将一直阻塞，至关于一辆车占了一个车位，此方法会响应线程中断，表示调用线程的interrupt方法，会使该方法抛出InterruptedException异常ide
-
void acquire(int permits) throws InterruptedException ：和acquire()方法相似，参数表示须要获取许可的数量；好比一个大卡车要入停车场，因为车比较大，须要申请3个车位才能够停放高并发
-
void acquireUninterruptibly(int permits) ：和acquire(int permits) 方法相似，只是不会响应线程中断
-
boolean tryAcquire()：尝试获取1个许可，不论是否可以获取成功，都当即返回，true表示获取成功，false表示获取失败
-
boolean tryAcquire(int permits)：和tryAcquire()，表示尝试获取permits个许可
-
boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException：尝试在指定的时间内获取1个许可，获取成功返回true，指定的时间事后仍是没法获取许可，返回false
-
boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException：和tryAcquire(long timeout, TimeUnit unit)相似，多了一个permits参数，表示尝试获取permits个许可
-
void release()：释放一个许可，将其返回给信号量，至关于车从停车场出去时将钥匙归还给门卫
-
void release(int n)：释放n个许可
-
int availablePermits()：当前可用的许可数
示例1：Semaphore简单的使用
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公众号：路人甲Java，专一于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
*/
public class Demo1 {
static Semaphore semaphore = new Semaphore(2);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",释放许可!");
}
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new T("t-" + i).start();
}
}
}
输出：
1563715791327,t-0,获取许可! 1563715791327,t-1,获取许可! 1563715794328,t-0,释放许可! 1563715794328,t-5,获取许可! 1563715794328,t-1,释放许可! 1563715794328,t-2,获取许可! 1563715797328,t-2,释放许可! 1563715797328,t-6,获取许可! 1563715797328,t-5,释放许可! 1563715797328,t-3,获取许可! 1563715800329,t-6,释放许可! 1563715800329,t-9,获取许可! 1563715800329,t-3,释放许可! 1563715800329,t-7,获取许可! 1563715803330,t-7,释放许可! 1563715803330,t-8,获取许可! 1563715803330,t-9,释放许可! 1563715803330,t-4,获取许可! 1563715806330,t-8,释放许可! 1563715806330,t-4,释放许可!
代码中new Semaphore(2)建立了许可数量为2的信号量，每一个线程获取1个许可，同时容许两个线程获取许可，从输出中也能够看出，同时有两个线程能够获取许可，其余线程须要等待已获取许可的线程释放许可以后才能运行。为获取到许可的线程会阻塞在acquire()方法上，直到获取到许可才能继续。
示例2：获取许可以后不释放
门卫（Semaphore）有点呆，司机进去的时候给了钥匙，出来的时候不归还，门卫也不会说什么。最终结果就是其余车辆都没法进入了。
以下代码：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公众号：路人甲Java，专一于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
*/
public class Demo2 {
static Semaphore semaphore = new Semaphore(2);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可!");
TimeUnit.SECONDS.sleep(3);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new T("t-" + i).start();
}
}
}
输出：
1563716603924,t-0,获取许可! 1563716603924,t-1,获取许可! 1563716606925,t-0,运行结束! 1563716606925,t-0,当前可用许可数量:0 1563716606925,t-1,运行结束! 1563716606925,t-1,当前可用许可数量:0
上面程序运行后一直没法结束，观察一下代码，代码中获取许可后，没有释放许可的代码，最终致使，可用许可数量为0，其余线程没法获取许可，会在semaphore.acquire();处等待，致使程序没法结束。
示例3：释放许可正确的姿式
示例1中，在finally里面释放锁，会有问题么？
若是获取锁的过程当中发生异常，致使获取锁失败，最后finally里面也释放了许可，最终会怎么样，致使许可数量凭空增加了。
示例代码：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公众号：路人甲Java，专一于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
*/
public class Demo3 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
try {
semaphore.acquire();
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
//休眠100秒
TimeUnit.SECONDS.sleep(100);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
//给t2和t3发送中断信号
t2.interrupt();
t3.interrupt();
}
}
输出：
1563717279058,t1,获取许可,当前可用许可数量:0 java.lang.InterruptedException 1563717281060,t2,当前可用许可数量:1 at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998) 1563717281060,t3,当前可用许可数量:2 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304) at java.util.concurrent.Semaphore.acquire(Semaphore.java:312) at com.itsoku.chat12.Demo3$T.run(Demo3.java:21) java.lang.InterruptedException at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302) at java.util.concurrent.Semaphore.acquire(Semaphore.java:312) at com.itsoku.chat12.Demo3$T.run(Demo3.java:21)
程序中信号量许可数量为1，建立了3个线程获取许可，线程t1获取成功了，而后休眠100秒。其余两个线程阻塞在semaphore.acquire();方法处，代码中对线程t二、t3发送中断信号，咱们看一下Semaphore中acquire的源码：
public void acquire() throws InterruptedException
这个方法会响应线程中断，主线程中对t二、t3发送中断信号以后，acquire()方法会触发InterruptedException异常，t二、t3最终没有获取到许可，可是他们都执行了finally中的释放许可的操做，最后致使许可数量变为了2，致使许可数量增长了。因此程序中释放许可的方式有问题。须要改进一下，获取许可成功才去释放锁。
正确的释放锁的方式，以下：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公众号：路人甲Java，专一于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
*/
public class Demo4 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
//获取许但是否成功
boolean acquireSuccess = false;
try {
semaphore.acquire();
acquireSuccess = true;
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可,当前可用许可数量:" + semaphore.availablePermits());
//休眠100秒
TimeUnit.SECONDS.sleep(5);
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",运行结束!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (acquireSuccess) {
semaphore.release();
}
}
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",当前可用许可数量:" + semaphore.availablePermits());
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
//给t2和t3发送中断信号
t2.interrupt();
t3.interrupt();
}
}
输出：
1563717751655,t1,获取许可,当前可用许可数量:0 1563717753657,t3,当前可用许可数量:0 java.lang.InterruptedException 1563717753657,t2,当前可用许可数量:0 at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1302) at java.util.concurrent.Semaphore.acquire(Semaphore.java:312) at com.itsoku.chat12.Demo4$T.run(Demo4.java:23) java.lang.InterruptedException at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(AbstractQueuedSynchronizer.java:998) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(AbstractQueuedSynchronizer.java:1304) at java.util.concurrent.Semaphore.acquire(Semaphore.java:312) at com.itsoku.chat12.Demo4$T.run(Demo4.java:23) 1563717756656,t1,运行结束! 1563717756656,t1,当前可用许可数量:1
程序中增长了一个变量acquireSuccess用来标记获取许但是否成功，在finally中根据这个变量是否为true，来肯定是否释放许可。
示例4：在规定的时间内但愿获取许可
司机来到停车场，发现停车场已经满了，只能在外等待内部的车出来以后才能进去，可是要等多久，他本身也不知道，他但愿等10分钟，若是仍是没法进去，就不到这里停车了。
Semaphore内部2个方法能够提供超时获取许可的功能：
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
throws InterruptedException
在指定的时间内去尝试获取许可，若是可以获取到，返回true，获取不到返回false。
示例代码：
package com.itsoku.chat12;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
* 微信公众号：路人甲Java，专一于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
*/
public class Demo5 {
static Semaphore semaphore = new Semaphore(1);
public static class T extends Thread {
public T(String name) {
super(name);
}
@Override
public void run() {
Thread thread = Thread.currentThread();
//获取许但是否成功
boolean acquireSuccess = false;
try {
//尝试在1秒内获取许可，获取成功返回true，不然返回false
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",尝试获取许可,当前可用许可数量:" + semaphore.availablePermits());
acquireSuccess = semaphore.tryAcquire(1, TimeUnit.SECONDS);
//获取成功执行业务代码
if (acquireSuccess) {
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可成功,当前可用许可数量:" + semaphore.availablePermits());
//休眠5秒
TimeUnit.SECONDS.sleep(5);
} else {
System.out.println(System.currentTimeMillis() + "," + thread.getName() + ",获取许可失败,当前可用许可数量:" + semaphore.availablePermits());
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (acquireSuccess) {
semaphore.release();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
T t1 = new T("t1");
t1.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t2 = new T("t2");
t2.start();
//休眠1秒
TimeUnit.SECONDS.sleep(1);
T t3 = new T("t3");
t3.start();
}
}
输出：
1563718410202,t1,尝试获取许可,当前可用许可数量:1 1563718410202,t1,获取许可成功,当前可用许可数量:0 1563718411203,t2,尝试获取许可,当前可用许可数量:0 1563718412203,t3,尝试获取许可,当前可用许可数量:0 1563718412204,t2,获取许可失败,当前可用许可数量:0 1563718413204,t3,获取许可失败,当前可用许可数量:0
代码中许可数量为1，semaphore.tryAcquire(1, TimeUnit.SECONDS);：表示尝试在1秒内获取许可，获取成功当即返回true，超过1秒仍是获取不到，返回false。线程t1获取许可成功，以后休眠了5秒，从输出中能够看出t2和t3都尝试了1秒，获取失败。
其余一些使用说明
- Semaphore默认建立的是非公平的信号量，什么意思呢？这个涉及到公平与非公平。举个例子：5个车位，容许5个车辆进去，来了100辆车，只能进去5辆，其余95在外面排队等着。里面恰好出来了1辆，此时恰好又来了10辆车，这10辆车是直接插队到其余95辆前面去，仍是到95辆后面去排队呢？排队就表示公平，直接去插队争抢第一个，就表示不公平。对于停车场，排队确定更好一些咯。不过对于信号量来讲不公平的效率更高一些，因此默认是不公平的。
- 建议阅读如下Semaphore的源码，对经常使用的方法有个了解，不须要都记住，用的时候也方便查询就好。
- 方法中带有
throws InterruptedException声明的，表示这个方法会响应线程中断信号，什么意思？表示调用线程的interrupt()方法，会让这些方法触发InterruptedException异常，即便这些方法处于阻塞状态，也会当即返回，并抛出InterruptedException异常，线程中断信号也会被清除。
java高并发系列
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933019&idx=1&sn=3455877c451de9c61f8391ffdc1eb01d&chksm=88621aa5bf1593b377e2f090bf37c87ba60081fb782b2371b5f875e4a6cadc3f92ff6d747e32&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第1天:必须知道的几个概念</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933024&idx=1&sn=969bfa5e2c3708e04adaf6401503c187&chksm=88621a9ebf1593886dd3f0f5923b6f929eade0b43204b98a8d0622a5f542deff4f6a633a13c8&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第2天:并发级别</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933041&idx=1&sn=82af7c702f737782118a9141858117d1&chksm=88621a8fbf159399be1d4834f6f845fa530b94a4ca7c0eaa61de508f725ad0fab74b074d73be&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第3天:有关并行的两个重要定律</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933050&idx=1&sn=497c4de99086f95bed11a4317a51e6a6&chksm=88621a84bf159392c9e3e243355313c397e0658df6b88769cdd182cb5d39b6f25686c86beffc&token=2041017112&lang=zh_CN#rd1">java高并发系列 - 第4天:JMM相关的一些概念</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933069&idx=1&sn=82105bb5b759ec8b1f3a69062a22dada&chksm=88621af3bf1593e5ece7c1da3df3b4be575271a2eaca31c784591ed0497252caa1f6a6ec0545&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第5天:深刻理解进程和线程</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933082&idx=1&sn=e940c4f94a8c1527b6107930eefdcd00&chksm=88621ae4bf1593f270991e6f6bac5769ea850fa02f11552d1aa91725f4512d4f1ff8f18fcdf3&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第6天:线程的基本操做</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933088&idx=1&sn=f1d666dd799664b1989c77441b9d12c5&chksm=88621adebf1593c83501ac33d6a0e0de075f2b2e30caf986cf276cbb1c8dff0eac2a0a648b1d&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第7天:volatile与Java内存模型</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933095&idx=1&sn=d32242a5ec579f45d1e9becf44bff069&chksm=88621ad9bf1593cf00b574a8e0feeffbb2c241c30b01ebf5749ccd6b7b64dcd2febbd3000581&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第8天:线程组</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933102&idx=1&sn=5255e94dc2649003e01bf3d61762c593&chksm=88621ad0bf1593c6905e75a82aaf6e39a0af338362366ce2860ee88c1b800e52f5c6529c089c&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第9天：用户线程和守护线程</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933107&idx=1&sn=6b9fbdfa180c2ca79703e0ca1b524b77&chksm=88621acdbf1593dba5fa5a0092d810004362e9f38484ffc85112a8c23ef48190c51d17e06223&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第10天:线程安全和synchronized关键字</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933111&idx=1&sn=0a3592e41e59d0ded4a60f8c1b59e82e&chksm=88621ac9bf1593df5f8342514d6750cc8a833ba438aa208cf128493981ba666a06c4037d84fb&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第11天:线程中断的几种方式</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933116&idx=1&sn=83ae2d1381e3b8a425e65a9fa7888d38&chksm=88621ac2bf1593d4de1c5f6905c31c7d88ac4b53c0c5c071022ba2e25803fc734078c1de589c&token=2041017112&lang=zh_CN#rd">java高并发系列 - 第12天JUC:ReentrantLock重入锁</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933120&idx=1&sn=63ffe3ff64dcaf0418816febfd1e129a&chksm=88621b3ebf159228df5f5a501160fafa5d87412a4f03298867ec9325c0be57cd8e329f3b5ad1&token=476165288&lang=zh_CN#rd">java高并发系列 - 第13天:JUC中的Condition对象</a>
- <a target="_blank" href="https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933125&idx=1&sn=382528aeb341727bafb02bb784ff3d4f&chksm=88621b3bbf15922d93bfba11d700724f1e59ef8a74f44adb7e131a4c3d1465f0dc539297f7f3&token=1338873010&lang=zh_CN#rd">java高并发系列 - 第14天:JUC中的LockSupport工具类，必备技能</a>
java高并发系列连载中，总计估计会有四五十篇文章，能够关注公众号：javacode2018，送月薪3万课程，获取最新文章。 
原文出处：https://www.cnblogs.com/itsoku123/p/11223837.html
相关文章
- 1. java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能
- 2. java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能
- 3. java并发系列 - 第30天：JUC中工具类CompletableFuture，必备技能
- 4. java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技
- 5. java高并发系列 - 第13天:JUC中的Condition对象
- 6. 突击并发编程JUC系列-并发工具 Semaphore
- 7. java高并发系列 - 第6天:线程的基本操做，必备技能
- 8. 【Java并发工具类】Semaphore
- 9. java并发系列 - 第29天：高并发中常见的限流方式
- 10. JUC-并发工具(CountDownLatch\CycleBarrier\Semaphore)
- 更多相关文章...
- • 高并发系统的分析和设计 - 红包项目实战
- • 使用流水线（pipelined）提高Redis的命令性能 - Redis教程
- • PHP开发工具
- • C# 中 foreach 遍历的用法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解决方法
- 2. Qt5.7以上调用虚拟键盘(支持中文)，以及源码修改(可拖动，水平缩放)
- 3. 软件测试面试- 购物车功能测试用例设计
- 4. ElasticSearch（概念篇）：你知道的, 为了搜索…
- 5. redux理解
- 6. gitee创建第一个项目
- 7. 支持向量机之硬间隔（一步步推导，通俗易懂）
- 8. Mysql 异步复制延迟的原因及解决方案
- 9. 如何在运行SEPM配置向导时将不可认的复杂数据库密码改为简单密码
- 10. windows系统下tftp服务器使用
欢迎关注本站公众号,获取更多信息
相关文章
- 1. java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能
- 2. java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能
- 3. java并发系列 - 第30天：JUC中工具类CompletableFuture，必备技能
- 4. java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技
- 5. java高并发系列 - 第13天:JUC中的Condition对象
- 6. 突击并发编程JUC系列-并发工具 Semaphore
- 7. java高并发系列 - 第6天:线程的基本操做，必备技能
- 8. 【Java并发工具类】Semaphore
- 9. java并发系列 - 第29天：高并发中常见的限流方式
- 10. JUC-并发工具(CountDownLatch\CycleBarrier\Semaphore)