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

单例模式

有些对象，在一个程序中应该只有唯一一个实例（光靠人保证不靠谱借助语法来保证）就可以使用单例模式

在单例模式下对象的实例化被限制了只能创建一个多了的也创建不了

单例模式分为两种：饿汉模式和懒汉模式

饿汉模式：

饿急眼了，不吃（创建）不行了，就是在类定义时就创建一个实例
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不行) 每次加入新元素都唤醒线程一下如果这个新元素的时间比之前的时间要早那就变成按照新的队首元素判断如果比之前的首元素时间要晚也无所谓接着等呗

一个误区

这里这个synchronized 用的是locker作为对象但是queue.put没有使用locker的资源是不是就锁不住了? 并不是它既然锁住了locker 那么其他线程在运行代码块的时候获取不到locker(已经被锁住) 还是会阻塞所以达成了目的

线程池

进程太重量了创建和销毁成本较高

线程就是针对上述问题的优化(公用一组系统资源)

但是更频繁的话线程也扛不住了

进一步优化

1.线程池

2.协程(纤程) 轻量级线程

八线程创建好放在池里需要使用直接从线程池里面取用完还回去就不需要创建和销毁

相当于十个线程去运行这个一百个任务

模拟实现

这个线程是持续运行的只要submit有东西输入进去了就会把它运行

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

单例模式

生产者消费者模型

定时器

线程池

猜你喜欢