阅读量:4
单例模式->是一种固定套路,类似于"棋谱",按照套路来,可以避免一些问题
单例模式的特点->能够保证在某个类中只存在一个实例,不会创建多个实例
饿汉模式(线程安全):最基础的单例模式,类加载的同时就会创建实例,是线程安全的
public class Singleton { // 在类加载时就完成了实例化，避免了线程同步的问题 private static Singleton instance = new Singleton(); private Singleton() {}// 私有构造函数，防止被外部实例化 public static Singleton getInstance() {// 获取单例对象的静态方法 return instance; } }懒汉模式 (线程不安全):类加载的时候不会创建实例,第一次使用的时候才创建实例,线程不安全
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确保多线程情况下的内存可见性和禁止指令重排序
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
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和读写操作都要上锁,并且是一把锁才有用
代码实现
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); } } 运行结果
使用模拟实现的阻塞队列实现生产者消费者模型
只需要更改主函数内容
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多个才开始消费第一个的情况
