单例模式->是一种固定套路,类似于"棋谱",按照套路来,可以避免一些问题
单例模式的特点->能够保证在某个类中只存在一个实例,不会创建多个实例
饿汉模式(线程安全):最基础的单例模式,类加载的同时就会创建实例,是线程安全的
java
public class Singleton {
// 在类加载时就完成了实例化，避免了线程同步的问题
private static Singleton instance = new Singleton();
private Singleton() {}// 私有构造函数，防止被外部实例化
public static Singleton getInstance() {// 获取单例对象的静态方法
return instance;
}
}懒汉模式 (线程不安全):类加载的时候不会创建实例,第一次使用的时候才创建实例,线程不安全
java
public class SingleLaze {
private static volatile SingleLaze instance = null;
private SingleLaze() {} // 私有构造函数，防止外部实例化
public static SingleLaze getInstance() {
if (instance == null) { //首次调用get方法instance==null才会创建实例
instance = new SingleLaze();
}
return instance;
}
}懒汉模式(线程安全版)
两个懒汉模式横向对比可以发现,修改后的加上了锁和双重if判定以及给instance加上lvolatile
- 加锁/解锁在懒汉模式只会发生在第一次创建实例的时候,后面使用的时候就不需要加锁
- 外层的if是判断当前是否已有实例对象
- 内层if是判定是否需要创建对象,由于第一个if语句和第二个if语句之间 因为synchronized发生的阻塞过程中,期间可能instance被其他线程创建了实例,所以双重判定在多线程/阻塞中很有必要
- volatile修饰instance确保多线程情况下的内存可见性和禁止指令重排序
java
public class SingleLaze {
private static volatile SingleLaze instance = null;
private SingleLaze() {} // 私有构造函数，防止外部实例化
public static SingleLaze getInstance() {
if (instance == null) { // 第一次检查，避免已有实例对象,再次创建新的对象情况
synchronized (SingleLaze.class) { // 使用类对象作为锁,里面表示了singlelaze这个类
if (instance == null) { // 第二次检查，确保单例
instance = new SingleLaze();
}
}
}
return instance;
}
}阻塞队列是什么?
- 阻塞队列是一种线程安全的数据结构,并具有以下特性
- 当队列空的时候,出队列操作就会阻塞,直到有元素入队列
- 当队列满的时候,入队列操作就会阻塞,直到有元素出队列
为什么要用阻塞队列?
在包饺子的场景中,如果不用阻塞队列,擀饺子皮的一直擀,但是包饺子的包的很慢,会出现饺子皮摆不下桌子的情况,如果用到阻塞队列,擀的人快,在桌子摆不下的情况就会阻塞等待,直到桌子能摆的下再擀,而包饺子快的情况下,就会等有饺子皮再包
标准库中阻塞队列BlockingQueue
java
BlockingQueue<String> queue=new ArrayBlockingQueue<String>(1000);
//创建新的阻塞队列,元素类型string,元素个数1000
queue.put("abc");//put阻塞式入队列
// 需要throws声明可能会抛出异常
String elem=queue.take();//阻塞式出队列
//elem元素模拟实现阻塞队列
- 使用循环队列的方式来实现
- put插入元素的时候,判定如果队列满了,就进行wait(需要注意要循环进行wait,可能在被唤醒的时候队列依旧是满的)
- take取出元素的时候,判定如果队列为空,就进行wait(也需要循环wait,确保线程在唤醒后能够再次检查等待条件，从而避免虚假唤醒等问题)
- 唤醒需要注意逻辑问题,wait是在满了或者空了的情况下才会运行,并且数据不可能是又满又空的状态,所以一次只会唤醒一个wait,两个wait不会同时运行,只有put下面的notify才能唤醒take上的wait,同理也只有take下面的notify才能唤醒put的wait
- 注意while和读写操作都要上锁,并且是一把锁才有用
代码实现
java
public class MyBlockingQueue1 {
//为了简单,不写作泛型,只考虑元素类型是string
private String[]elems=null;
private int head=0;//指向头结点下标
private int tail=0;//指向尾节点下标
private int size=0;//当前数组所存的元素个数
//准备锁对象
private Object locker =new Object();
public MyBlockingQueue1(int capacity){//使用构造函数指定阻塞队列的最大容量
elems=new String[capacity];
}
public void put(String elem) throws InterruptedException {
synchronized (locker){
while (size>=elems.length){
locker.wait();//当前所占容量等于或超过最大容量,就阻塞等待
}
//没满
elems[tail++]=elem;//将传入的元素从尾节点插入到数组,同时尾节点++
if(tail>= elems.length){
tail=0;
}
size++;//元素个数++
//入队成功后唤醒可能在take时候阻塞的wait
locker.notify();
}
}
public String take() throws InterruptedException {
String elem=null;//在锁里面创建对象就在锁外面返回不了
synchronized (locker){
while (size==0){
locker.wait();//当前数组元素为0,就阻塞等待
}
//没空
elem=elems[head++];
if(head>= elems.length){
head=0;
}
size--;//元素个数++
//入队成功后唤醒可能在take时候阻塞的wait
locker.notify();
}
return elem;
}
public static void main(String[] args) throws InterruptedException {
MyBlockingQueue1 queue=new MyBlockingQueue1(1000);
queue.put("aaa");
queue.put("bbb");
queue.put("ccc");
queue.put("ddd");
String elem= queue.take();
System.out.println("elem="+elem);
elem= queue.take();
System.out.println("elem="+elem);
elem= queue.take();
System.out.println("elem="+elem);
elem= queue.take();
System.out.println("elem="+elem);
}
}运行结果
使用模拟实现的阻塞队列实现生产者消费者模型
只需要更改主函数内容
java
public static void main(String[] args) {
MyBlockingQueue1 queue=new MyBlockingQueue1(1000);
//生产者
Thread t1=new Thread(()->{
int n=1;
while (true){
try {
queue.put(n+"");
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("生产元素"+n);
n++;
}
});
//消费者
Thread t2=new Thread(()->{
while (true){
try {
String n= queue.take();
System.out.println("消费元素"+n);
// Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t2.start();
}
}如果在生产后加上延时,消费后不加延时,就会出现生产一个消费一个的情况
如果在消费后面加上延时而生产后面不加延时,就会出现生产了1000多个才开始消费第一个的情况
