Java-线程安全的四个经典案例和线程池

墨蓝 2023-10-10 18:12 20阅读 0赞

> ### 单例模式 ###
> 
> 有些对象，在一个程序中应该只有唯一 一个实例（光靠人保证不靠谱 借助语法来保证） 就可以使用单例模式
> 
> 在单例模式下 对象的实例化被限制了 只能创建一个 多了的也创建不了
> 
> 单例模式分为两种：饿汉模式和懒汉模式
> 
> 饿汉模式：
> 
> 饿急眼了，不吃（创建）不行了，就是在类定义时就创建一个实例
> 
>     Class Singleton{
>     private static singleton instance= new singleton();
>     public static Singleton getInstance（）{
>     return instance；
>     }
>     Private Singleton(){
>     }(防止new实例)
>     };
> 
> static 静态 实际效果和字面含义没啥关系 实际的含义是 类属性/类方法（对应实例属性实例方法）类对象只能创建一个
> 
> 效果是无论get多少个实例都是同一个实例 且无法new实例
> 
> 懒汉模式:
> 
> ε=(´ο｀\*))) 啥时候用啥时候再创建吧
> 
>     class Singletonlazy {
>              private static Singgletonlazy instance = null;
>              public static Singletonlazy getInstance(){
>              If(instance == null){
>                 Instance = new Singletonlazy();
>     }
>     Return instance;
>     }
>     }
> 
> 那么回到多线程,饿汉模式和懒汉模式是线程安全的吗
> 
> 饿汉模式get只是多线程读 没问题
> 
> 懒汉模式 第一次调用get有的地方在读有的地方在写 实例创建好之后就安全了(一个线程在读 一个线程在创建 还没创建完 就读了 就又创建了)
> 
> 所以我们可以选择对它加锁
> 
>     synchronized(SingletonLazy.class){
>      If(instance == null){
>                 Instance = new Singletonlazy();
>     }}
> 
> 但是如果这么写的话,每次的判断操作也被锁了,多线程中还是不可以同时运行(一个判断另一个就会阻塞)所以我们可以
> 
>     if(instance==null){
>     synchronized(SingletonLazy.class){
>      If(instance == null){
>                 Instance = new Singletonlazy();
>     }}}
> 
> 在单线程中我们连续使用两个相同的if没有意义 但是隔了一个synchronized就是另一说了
> 
> 饿汉模式和懒汉模式是一种设计思想 不是固定的代码 我们再举一个例子
> 
> 1.饿汉 把10g都读取到内存中 读取完毕之后再允许用户进行查看和修改
> 
> 2.懒汉 一次只读一点 随着用户翻页 继续再读后续内容

> ### 生产者消费者模型 ###
> 
> 先来了解一下 阻塞队列
> 
> 阻塞队列和正常队列的区别是啥子呢 就是当对列为空 尝试出队列 就会阻塞。队列为满时 尝试入队列也会阻塞
> 
> 生产者消费者模型就是通过阻塞队列实现的
> 
> 我们用包饺子来举例 把包出饺子作为最终目标(没有煮饺子 吃饺子的环节)
> 
> 一个人擀饺子皮 其他人包（因为擀面杖数量有限 所以效率会远高于 每个人自己擀饺子皮自己包）
> 
> 生产者消费者模型（必须得有盖帘才算生产者消费者模型）
> 
> 生产者：负责擀饺子皮
> 
> 盖帘： 阻塞队列
> 
> 消费者：负责包饺子的人
> 
> 生产者消费者模型的好处是什么
> 
> 1.可以做到更好的解耦合（高内聚就是写一个功能的时候尽量让这个功能的代码集中放置 不要东一块西一块）
> 
> 如果生产者和消费者直接交互 耦合性很高 b寄了可能给a也干碎了
> 
> 如果 生产者->阻塞队列->消费者 双方只想着和阻塞队列交互就可以了 他俩谁寄了都不影响对方
> 
> 2.削峰填谷（就跟三峡大坝似得 把雨季的水给旱季） 提高整个系统的抗风险能力
> 
> 大规模用户同时访问a a再给b同步 b如果没有太强抗压能力可能就寄了
> 
> 生产者消费者模型
> 
> 在a和b之间放一个阻塞队列 即使a的压力很大 b仍然按照既定的频率来取数据
> 
> 代码实现
> 
>     public static void main(String[] args) {
>                 BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
>                 Thread productor = new Thread(()->{
>                 	int n = 0;
>                 	while(true) {
>                 		try {
>     						System.out.println("生产元素"+n);
>     						queue.put(n);
>     						n++;
>     						Thread.sleep(500);//这行代码,没有实际意义 是为了让运行结果更方便观察而已
>     					} catch (Exception e) {
>     						e.printStackTrace();
>     					}
>                 	}
>                 });
>                 productor.start();
>                 Thread customer = new Thread(()->{
>                 	while(true) {
>                 		try {
>     						System.out.println("消费元素"+queue.take());				
>     						Thread.sleep(500);
>     					} catch (Exception e) {
>     						e.printStackTrace();
>     					}
>                 	}
>                 });
>                 customer.start();
>     	    }
> 
> 模拟实现一个阻塞队列
> 
>     class myqueue{
>     	int[] queue = new int[100];
>     	int size = 0;
>     	int head = 0;
>     	int tail = 0;
>     	
>     	public void put(int a) throws InterruptedException{
>     		synchronized (this) {
>     			if(size==queue.length) {
>     				this.wait();
>     			}
>     			
>     			queue[tail] = a;
>     			tail++;
>     			if(tail==queue.length) {
>     				tail = 0;
>     			}
>     			size++;
>     			this.notify();
>     		}
>     	}
>     	public Integer take() throws InterruptedException{
>     		int ret = 0;
>     		synchronized (this) {
>     			if(size==0) {
>     				this.wait();
>     			}
>     			ret = queue[head];
>     			head++;
>     			if(head==queue.length) {
>     				head=0;
>     			}
>     			size--;
>     			this.notify();
>     			return ret;
>     		}
>     	}
>     }
> 
> 不要担心这个notify唤醒的是当前功能的wait 因为如果有wait就做不到这一步

> #### 定时器 ####
> 
> 使用方法是这样的
> 
> 先实例化一个Timer对象
> 
> 然后调用它的schedule方法
> 
> schedule有两个参数 第一个参数是Timertask对象 重写里面的run 就是业务代码
> 
> 第二个参数是时间 一个整形 单位ms
> 
>     public static void main(String[] args) {
>                 Timer timer = new Timer();
>                 timer.schedule(new TimerTask() {			
>     				@Override
>     				public void run() {
>     					System.out.println("任务");
>     								}
>     			}, 1000);
>     	    }
> 
> 你可能会问那我直接用sleep多好
> 
> sleep把线程阻塞了 什么都干不了 但是定时器等待的过程中还可以干别的
> 
> command表示任务 after表示暂停多久
> 
> 这个schedule(时间表) 这是个表啊 也就是说可以放入多个元素
> 
> 模拟实现
> 
> Timer 内部要组织很多任务
> 
> 还需要有一个线程 通过这个线程来扫描定时器内部 看看哪个时间到了该执行了
> 
> 使用优先级队列来组织这些任务 使用优先级队列可以排序时间
> 
> System.currentTimeMillis()系统当前时间戳\\
> 
> PriorityQueue<MyTask> queue
> 
> 这个队列会被多个线程同时访问
> 
> schedule可能在多线程中被调用 每次调用都要往队列里添加元素
> 
> 内部还需要有专门的线程执行任务
> 
> 涉及到出入 所以不安全
> 
> PriorityBlockingQueue用阻塞队列
> 
> public void schedule()
> 
> 进入构造就创建一个线程 循环不断尝试获取队首元素并且判定元素是否可以就绪(大量的产生循环 空转 没有实际性的任务)
> 
> 所以 在判断结束(不可就绪)后 就让他等一会(sleep 不行 即使可以就绪了sleep还在休息 可以用wait wait可以提前唤醒)(每次插入任务都唤醒判断一下)
> 
> 都统一的时间戳 如果规定时间比当前时间大(没到时间呢)就塞回去
> 
> 如果到了 就执行
> 
> 优先级队列需要定义优先原则 实现Comparable接口 并重写compareTo 所以要在被比较元素的类里面写
> 
> 这个return 谁减谁 可以写代码试( 如果第一个参数小于第二个参数，就返回一个负数，如果等于就返回0，如果大于就返回一个正数。而且要求返回int 还要强转)
> 
> private Object locker = new Object();
> 
> wait 和 notify 都是java.util里面的文件 创建一个object类就可以
> 
> 原则上来讲 只要判断队首元素就可以(等待时间最少) 但是要防止新加入的元素比队首时间还小 (所以加了notify 所以说用sleep不行) 每次加入新元素都唤醒线程一下 如果这个新元素的时间比之前的时间要早 那就变成按照新的队首元素判断 如果比之前的首元素时间要晚也无所谓 接着等呗
> 
> ![37d8ae442fd34830be2f0b1d67ddf29a.png][]
> 
> 一个误区
> 
> ![2b71c3031227405a8fec7191d694095b.png][]
> 
> 这里这个synchronized 用的是locker作为对象 但是queue.put没有使用locker的资源 是不是就锁不住了? 并不是 它既然锁住了locker 那么其他线程在运行代码块的时候获取不到locker(已经被锁住) 还是会阻塞 所以达成了目的

> #### 线程池 ####
> 
> 进程太重量了 创建和销毁成本较高
> 
> 线程 就是针对上述问题的优化(公用一组系统资源)
> 
> 但是更频繁的话 线程也扛不住了
> 
> 进一步优化
> 
> 1.线程池
> 
> 2.协程(纤程) 轻量级线程
> 
> 八线程创建好 放在池里 需要使用直接从线程池里面取 用完还回去 就不需要创建和销毁
> 
> ![fd47b0438cdf4440931ae90ca9a832d1.png][]
> 
> 相当于十个线程去运行这个一百个任务
> 
> 模拟实现
> 
> ![29dff9a6da1441ba8fe18622bd8497f9.png][]
> 
> 这个线程是持续运行的 只要submit有东西输入进去了 就会把它运行

[37d8ae442fd34830be2f0b1d67ddf29a.png]: https://img-blog.csdnimg.cn/37d8ae442fd34830be2f0b1d67ddf29a.png
[2b71c3031227405a8fec7191d694095b.png]: https://img-blog.csdnimg.cn/2b71c3031227405a8fec7191d694095b.png
[fd47b0438cdf4440931ae90ca9a832d1.png]: https://img-blog.csdnimg.cn/fd47b0438cdf4440931ae90ca9a832d1.png
[29dff9a6da1441ba8fe18622bd8497f9.png]: https://img-blog.csdnimg.cn/29dff9a6da1441ba8fe18622bd8497f9.png