技术标签： 高并发与线程安全
countDownLatch初始化一个数值，阻塞线程知道倒数到0触发事件
class countDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 0; i <=6 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t 上完自习，离开教室");
},String.valueOf(i)).start();
}
System.out.println(Thread.currentThread().getName()+"\t >>>>关门走人");
TimeUnit.SECONDS.sleep(2);
System.out.println("------------");
for (int i = 1; i <=6 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t 上完自习，离开教室");
countDownLatch.countDown();
},String.valueOf(i)).start();
}
//阻止主线程，等待子线程完成
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+"\t <<<<关门走人");
}
}
/*
1 上完自习，离开教室
2 上完自习，离开教室
main >>>>关门走人
3 上完自习，离开教室
4 上完自习，离开教室
0 上完自习，离开教室
5 上完自习，离开教室
6 上完自习，离开教室
------------
2 上完自习，离开教室
4 上完自习，离开教室
1 上完自习，离开教室
5 上完自习，离开教室
3 上完自习，离开教室
6 上完自习，离开教室
main <<<<关门走人
*/
cyclicBarrier向上计数，线程阻塞
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
System.out.println("召唤神龙");
});
for (int i = 1; i <=7; i++) {
final int tempint=i;
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t收集了第："+tempint+"颗龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
/*
2 收集了第：2颗龙珠
6 收集了第：6颗龙珠
3 收集了第：3颗龙珠
1 收集了第：1颗龙珠
7 收集了第：7颗龙珠
4 收集了第：4颗龙珠
5 收集了第：5颗龙珠
召唤神龙
*/
semaphore信号量
public class SemaphoreDemo {
public static void main(String[] args) {
//初始化资源数
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"\t抢到车位");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"\t我走了");
} catch (Exception e) {
e.printStackTrace();
}
finally {
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}
/*
2 抢到车位
1 抢到车位
3 抢到车位
2 我走了
3 我走了
1 我走了
6 抢到车位
4 抢到车位
5 抢到车位
6 我走了
5 我走了
4 我走了
*/
public enum CountryEnum {
ONE(1,"春"),TWO(2,"夏");
private Integer retId;
private String retMessage;
public Integer getRetId() {
return retId;
}
public String getRetMessage() {
return retMessage;
}
CountryEnum(Integer retId, String retMessage) {
this.retId = retId;
this.retMessage = retMessage;
}
public static CountryEnum getEnumForIndex(int index){
CountryEnum[] values = CountryEnum.values();
for (CountryEnum countryEnum: values) {
if (countryEnum.retId==index){
return countryEnum;
}
}
return null;
}
}
阻塞队列的好处？不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程。
阻塞队列如何管理？
何为阻塞队列？
阻塞队列分类
ArrayBlockingQueue：由数组结构组成的有限阻塞队列
LinkedBlockingQueue：由链表结构组成的有界阻塞队列（默认大小Integer.MAX_VALUE）
PriorityBlockingQueue：支持优先级排序的无界阻塞队列
DelayQueue：使用优先级队列实现的延迟无解阻塞队列
SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列
LinkedTransferQueue：由链表结构组成的无解阻塞队列
LinkedBlockingDeque：由链表结构组成的双向阻塞队列
阻塞队列的核心方法
抛出异常：当操作超过队列长度时，直接抛出异常
特殊值：进行尝试操作，如果成功返回true，失败返回false
阻塞：如果队列满了继续插入就阻塞线程，直到有元素移除；如果队列为空还要取出就阻塞线程
超时：只阻塞指定的超时时间
| 方法类型 | 抛出异常 | 特殊值 | 阻塞 | 超时 |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 移除 | remove() | poll() | take() | poll(time,unit) |
| 检查 | element() | peek() | 不可用 | 不可用 |
//抛出异常
public class BlockingQueueDemo {
public static void main(String[] args) {
arrayBlockingQueue_exception();
}
private static void arrayBlockingQueue_exception() {
//初始化一个大小为3的string阻塞队列
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
System.out.println(blockingQueue.element());
try {
System.out.println(blockingQueue.add("a"));
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("--------------------");
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.element());
try {
System.out.println(blockingQueue.remove());
} catch (Exception e) {
e.printStackTrace();
}
}
/*
true
true
true
a
java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(AbstractQueue.java:98)
at java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:312)
at queue.BlockingQueueDemo.main(BlockingQueueDemo.java:24)
--------------------
a
b
c
Exception in thread "main" java.util.NoSuchElementException
at java.util.AbstractQueue.element(AbstractQueue.java:136)
at queue.BlockingQueueDemo.main(BlockingQueueDemo.java:33)
*/
//特殊值
public class BlockingQueueDemo {
public static void main(String[] args) {
arrayBlockingQueue_special();
}
private static void arrayBlockingQueue_special() {
//初始化一个大小为3的string阻塞队列
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
System.out.println("队列已满尝试插入");
System.out.println(blockingQueue.offer("d"));
System.out.println("检查队列");
System.out.println(blockingQueue.peek());
System.out.println("移除元素");
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println("队列已空");
System.out.println(blockingQueue.poll());
}
}
/*
true
true
true
队列已满尝试插入
false
检查队列
a
移除元素
a
b
c
队列已空
null
*/
//阻塞
public class BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
arrayBlockingQueue_blocking();
}
private static void arrayBlockingQueue_blocking() throws InterruptedException {
//初始化一个大小为3的string阻塞队列
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
System.out.println("队列已满尝试插入,此时线程阻塞");
System.out.println(blockingQueue.peek());
blockingQueue.take();
blockingQueue.take();
blockingQueue.take();
System.out.println("队列已空,若继续清空线程阻塞");
}
}
//超时
public class BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
timeOut();
}
private static void timeOut() throws InterruptedException {
//初始化一个大小为3的string阻塞队列
ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);
//s瞬间插入
System.out.println(blockingQueue.offer("a", 2l, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("b", 2l, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("c", 2l, TimeUnit.SECONDS));
System.out.println("队列已满，此时尝试插入，等待两秒返回插入结果");
System.out.println(blockingQueue.offer("d", 2l, TimeUnit.SECONDS));
System.out.println(blockingQueue.poll(1l, TimeUnit.SECONDS));
System.out.println(blockingQueue.poll(1l, TimeUnit.SECONDS));
System.out.println(blockingQueue.poll(1l, TimeUnit.SECONDS));
System.out.println("队列已空，此时尝试获取，等待一秒返回获取结果");
System.out.println(blockingQueue.poll(1l, TimeUnit.SECONDS));
}
}
/*
true
true
true
队列已满，此时尝试插入，等待两秒返回插入结果
false
a
b
c
队列已空，此时尝试获取，等待一秒返回获取结果
null
*/
队列中只有一个元素，不消费就不生产
public class SycnhronousQueueDemo {
public static void main(String[] args) {
SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"\t put 1");
synchronousQueue.put("1");
System.out.println(Thread.currentThread().getName()+"\t put 2");
synchronousQueue.put("2");
System.out.println(Thread.currentThread().getName()+"\t put 3");
synchronousQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"AA").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("2s后");
System.out.println(Thread.currentThread().getName()+"\tget "+synchronousQueue.take());
TimeUnit.SECONDS.sleep(2);
System.out.println("2s后");
System.out.println(Thread.currentThread().getName()+"\tget "+synchronousQueue.take());
TimeUnit.SECONDS.sleep(2);
System.out.println("2s后");
System.out.println(Thread.currentThread().getName()+"\tget "+synchronousQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"BB").start();
}
}
/*
AA put 1
2s后
BB get 1
AA put 2
2s后
BB get 2
AA put 3
2s后
BB get 3
*/
生产者消费者模式
传统版
class ShareData{
private int number=0;
private Lock lock=new ReentrantLock();
private Condition condition=lock.newCondition();
public void increment() throws Exception{
try {
lock.lock();
//1判断,防止虚假唤醒
while (number!=0){
//等待，暂停生产
condition.await();
}
//2干活
number++;
System.out.println(Thread.currentThread().getName()+"\t "+number);
//3通知唤醒
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void decrement() throws Exception{
try {
lock.lock();
//1判断
while (number==0){
//等待，暂停生产
condition.await();
}
//2干活
number--;
System.out.println(Thread.currentThread().getName()+"\t "+number);
//3通知唤醒
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public class ProdConsumer_TranditionDemo {
public static void main(String[] args) {
ShareData shareData = new ShareData();
new Thread(()->{
for (int i = 1; i <= 5; i++) {
try {
shareData.increment();
} catch (Exception e) {
e.printStackTrace();
}
}
},"AA").start();
new Thread(()->{
for (int i = 1; i <= 5; i++) {
try {
shareData.decrement();
} catch (Exception e) {
e.printStackTrace();
}
}
},"BB").start();
}
}
/*
AA 1
BB 0
AA 1
BB 0
AA 1
BB 0
AA 1
BB 0
AA 1
BB 0
*/
虚假唤醒
阻塞队列版
class MyResource{
private volatile boolean flag=true;
private AtomicInteger atomicInteger=new AtomicInteger();
//定义基础接口
BlockingQueue<String> blockingQueue=null;
//通过构造传入具体的实现类
public MyResource(BlockingQueue<String> blockingQueue) {
this.blockingQueue = blockingQueue;
System.out.println(blockingQueue.getClass().getName());
}
public void myProd() throws InterruptedException {
String data=null;
boolean resValue;
while (flag){
data=atomicInteger.incrementAndGet()+"";
resValue=blockingQueue.offer(data,2l, TimeUnit.SECONDS);
if (resValue){
System.out.println(Thread.currentThread().getName()+"\t 插入队列成功"+data);
}else {
System.out.println(Thread.currentThread().getName()+"\t 插入队列失败" );
}
TimeUnit.SECONDS.sleep(1);
}
System.out.println(Thread.currentThread().getName()+"\t 生产叫停");
}
public void myConsumer() throws InterruptedException {
String result=null;
while (flag){
//外部设置flag时线程处于阻塞状态
result=blockingQueue.poll(2l,TimeUnit.SECONDS);
if (result==null||result.equalsIgnoreCase("")){
flag=false;
System.out.println(Thread.currentThread().getName()+"\t 消费失败");
break;
}
System.out.println(Thread.currentThread().getName()+"\t 消费队列"+result+"成功");
}
}
public void stop(){
System.out.println("开始停止生产");
flag=false;
}
}
public class ProdConsumer_BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(5);
MyResource myResource = new MyResource(blockingQueue);
new Thread(()->{
System.out.println("生产线程启动");
System.out.println();
System.out.println();
try {
myResource.myProd();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"生产者").start();
new Thread(()->{
System.out.println("消费线程启动");
System.out.println();
System.out.println();
try {
myResource.myConsumer();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"消费者").start();
TimeUnit.SECONDS.sleep(3);
myResource.stop();
}
}
/*
java.util.concurrent.ArrayBlockingQueue
生产线程启动
消费线程启动
生产者 插入队列成功1
消费者 消费队列1成功
生产者 插入队列成功2
消费者 消费队列2成功
生产者 插入队列成功3
消费者 消费队列3成功
开始停止生产
生产者 生产叫停
消费者 消费失败
*/
文章浏览阅读3.2k次。本文研究全球与中国市场分布式光纤传感器的发展现状及未来发展趋势，分别从生产和消费的角度分析分布式光纤传感器的主要生产地区、主要消费地区以及主要的生产商。重点分析全球与中国市场的主要厂商产品特点、产品规格、不同规格产品的价格、产量、产值及全球和中国市场主要生产商的市场份额。主要生产商包括：FISO TechnologiesBrugg KabelSensor HighwayOmnisensAFL GlobalQinetiQ GroupLockheed MartinOSENSA Innovati_预计2026年中国分布式传感器市场规模有多大
文章浏览阅读1.1k次，点赞2次，收藏12次。常用组合逻辑电路结构——为IC设计的延时估计铺垫学习目的：估计模块间的delay，确保写的代码的timing 综合能给到多少HZ，以满足需求！_基4布斯算法代码
文章浏览阅读3.3k次，点赞3次，收藏5次。OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版
文章浏览阅读2.2k次。USACO自1992年举办，到目前为止已经举办了27届，目的是为了帮助美国信息学国家队选拔IOI的队员，目前逐渐发展为全球热门的线上赛事，成为美国大学申请条件下，含金量相当高的官方竞赛。USACO的比赛成绩可以助力计算机专业留学，越来越多的学生进入了康奈尔，麻省理工，普林斯顿，哈佛和耶鲁等大学，这些同学的共同点是他们都参加了美国计算机科学竞赛（USACO)，并且取得过非常好的成绩。适合参赛人群USACO适合国内在读学生有意向申请美国大学的或者想锻炼自己编程能力的同学，高三学生也可以参加12月的第_usaco可以多次提交吗
文章浏览阅读394次。1.1 存储程序1.2 创建存储过程1.3 创建自定义函数1.3.1 示例1.4 自定义函数和存储过程的区别1.5 变量的使用1.6 定义条件和处理程序1.6.1 定义条件1.6.1.1 示例1.6.2 定义处理程序1.6.2.1 示例1.7 光标的使用1.7.1 声明光标1.7.2 打开光标1.7.3 使用光标1.7.4 关闭光标1.8 流程控制的使用1.8.1 IF语句1.8.2 CASE语句1.8.3 LOOP语句1.8.4 LEAVE语句1.8.5 ITERATE语句1.8.6 REPEAT语句。_mysql自定义函数和存储过程
文章浏览阅读188次。半导体二极管——集成电路最小组成单元。_本征半导体电流为0
文章浏览阅读2.8k次，点赞3次，收藏18次。游戏水面特效实现方式太多。咱们这边介绍的是一最简单的UV动画（无顶点位移），整个mesh由4个顶点构成。实现了水面效果（左图），不动代码稍微修改下参数和贴图可以实现岩浆效果（右图）。有要思路是1，uv按时间去做正弦波移动2，在1的基础上加个凹凸图混合uv3，在1、2的基础上加个水流方向4，加上对雾效的支持，如没必要请自行删除雾效代码(把包含fog的几行代码删除)S..._unity 岩浆shader
文章浏览阅读5k次。广义线性模型是线性模型的扩展，它通过连接函数建立响应变量的数学期望值与线性组合的预测变量之间的关系。广义线性模型拟合的形式为：其中g(μY)是条件均值的函数（称为连接函数）。另外，你可放松Y为正态分布的假设，改为Y 服从指数分布族中的一种分布即可。设定好连接函数和概率分布后，便可以通过最大似然估计的多次迭代推导出各参数值。在大部分情况下，线性模型就可以通过一系列连续型或类别型预测变量来预测正态分布的响应变量的工作。但是，有时候我们要进行非正态因变量的分析，例如：（1）类别型.._广义线性回归模型
文章浏览阅读69次。环境保护、 保护地球、 校园环保、垃圾分类、绿色家园、等网站的设计与制作。 总结了一些学生网页制作的经验：一般的网页需要融入以下知识点：div+css布局、浮动、定位、高级css、表格、表单及验证、js轮播图、音频 视频 Flash的应用、ul li、下拉导航栏、鼠标划过效果等知识点，网页的风格主题也很全面：如爱好、风景、校园、美食、动漫、游戏、咖啡、音乐、家乡、电影、名人、商城以及个人主页等主题，学生、新手可参考下方页面的布局和设计和HTML源码（有用点赞△） 一套A+的网_垃圾分类网页设计目标怎么写
文章浏览阅读614次，点赞7次，收藏11次。之前找到一个修改 exe 中 DLL地址 的方法, 不太好使,虽然能正确启动, 但无法改变 exe 的工作目录,这就影响了.Net 中很多获取 exe 执行目录来拼接的地址 ( 相对路径 ),比如 wwwroot 和 代码中相对目录还有一些复制到目录的普通文件 等等,它们的地址都会指向原来 exe 的目录, 而不是自定义的 “lib” 目录,根本原因就是没有修改 exe 的工作目录这次来搞一个启动程序,把 .net 的所有东西都放在一个文件夹,在文件夹同级的目录制作一个 exe._.net dll 全局目录
文章浏览阅读1.5k次。本文为转载，原博客地址：http://blog.csdn.net/hujingshuang/article/details/46910259简介 BRIEF是2010年的一篇名为《BRIEF:Binary Robust Independent Elementary Features》的文章中提出，BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度..._breif description calculation 特征点
文章浏览阅读4.1k次，点赞21次，收藏79次。本文是《基于SpringBoot的房屋租赁管理系统》的配套原创说明文档，可以给应届毕业生提供格式撰写参考，也可以给开发类似系统的朋友们提供功能业务设计思路。_基于spring boot的房屋租赁系统论文