每天学一点,每天进步一点,质的飞跃需要量的积累,add oil!!!
首先我们学任何一项技术都必须知道其应用的场景,其后我们再去学习它的使用方法
常见应用场景
windows的任务管理器,文件系统,
网站计数器
spring默认bean为单例
数据库连接池
读取配置文件的类对象
总结:只需要一个对象来解决问题时需要单例模式。可能有些不理解,可以在之后的学习慢慢体会
为什么要学单例模式?
单例模式在笔试面试中经常出现,且项目设计也会用到的设计模式。
下面我们就开始学习单例模式的使用,也是本文关键点
常见的五种单例模式实现方式
主要
学习下面两个可以应付一般的笔试面试
饿汉式(线程安全,调用效率高。但是,不能延时加载。)
懒汉式(线程安全,调用效率不高。但是,可以延时加载。)
其他
下面三点是吊打面试官系列,比较难,面试官都可能不知道。学好了面试加分,好好学哦。
双重检测锁式(由于JVM底层内部模型原因,偶尔会出问题。不建议使用)
静态内部类式(线程安全,调用效率高。但是,可以延时加载)
枚举单例(线程安全,调用效率高,不能延时加载,由JVM从根本上提供保障!避免通过反射和反序列化的漏洞)
下面我们逐个击破
饿汉式
顾名思义,饿汉它饥渴,所以…,直接上代码来理解
public class Hungry {
//饿汉它饥渴,一来就创建女朋友
//类初始化时,立即加载这个对象女朋友(没有延时加载的优势)。加载类时,天然的是线程安全
private static Hungry girlfriend = new Hungry();//注意:private,保证只能通过getInstance()方法来创建实例
private Hungry() {//注意:private,保证只能通过getInstance()方法来创建实例
}
//方法没有同步,调用效率高!
public static Hungry getInstance() {
return girlfriend;
}
}
public class Test {
public static void main(String[] args) {
Hungry girlfriend1 = Hungry.getInstance();
Hungry girlfriend2 = Hungry.getInstance();
System.out.println(girlfriend1 == girlfriend2);//永远是true
}
}
总结:
- 线程安全:类加载器加载对象是一个天然的线程安全,所以是线程安全的
- 可能造成资源浪费:如果加载了饿汉类,必然会创建女朋友,那如果这个饿汉又没有使用这个女朋友,必然会让其它男生少了一个可以选择的对象,造成资源的浪费
饿汉式单例模代码中, static变量会在类装载时初始化,此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类,肯定不会发生并发访问的问题。因此,可以省略 synchronized关键字。问题:如果只是加载本类,而不是要调用 getinstance0,甚至永远没有调用,则会造成资源浪费!
懒汉式
public class LazyMan {
//懒汉比较懒,没有找女朋友,等有需求了再找
//类初始化时,不初始化这个对象(延时加载,真正用的时候再创健建)。
private static LazyMan girlfriend;
//私有化构造器
public LazyMan() {
}
//方法同步,调用效率低
public static synchronized LazyMan getInstance(){
if (girlfriend == null) { //防止重复创建实例
girlfriend = new LazyMan();
}
return girlfriend;
}
}
public class Test {
public static void main(String[] args) {
LazyMan girlfriend1 = LazyMan.getInstance();
LazyMan girlfriend2 = LazyMan.getInstance();
System.out.println(girlfriend1 == girlfriend2);//true
}
}
为什么要加synchronized 关键字?
- 假设有A和B两个线程,A线程 执行到if (girlfriend == null) 挂起,此时没有创建对象,在A挂起的时间段内,B线程执行到if (girlfriend == null) ,判断条件成立,创建对象girlfriend ,此时A线程再次开始执行,又创建了一个对象girlfriend ,于是不满足单例模式只创建一个对象的条件。所以我们要在LazyMan 类前加锁。
总结:
- lazy load!延迟加载,懒加载!真正用的时候才加载
- 资源利用率高了。但是,每次调用 getinstance0方法都要同步,并发效率较低
双重检测锁式
public class DoubleCheckLock {
private static DoubleCheckLock instance = null;
public static DoubleCheckLock getInstance() {
if (instance == null) {
DoubleCheckLock sc;
synchronized (DoubleCheckLock.class) {
sc = instance;
if (sc == null) {
synchronized (DoubleCheckLock.class) {
if (sc == null)
sc = new DoubleCheckLock();
}
}
instance = sc;
}
}
return instance;
}
private DoubleCheckLock(){
}
}
总结:
- 这方法知道思想即可,实际工作中不会使用
- 这个模式将同步内容下方到内部,提高了执行的效率, 不必每次获取对象时都进行同步,只有第一次才同步,创建了以后就没必要了。
问题: - 由于编译器优化原医和JVM底层內部模型原因
- 偶尔会出问题。不建议使用
静态内部类式
其实也可以理解为懒加载,此方法重点掌握,框架也经常使用此方法
public class StaticInnerClass {
//定义静态内部类,初始化StaticInnerClass时,不会加载静态内部类
private static class SingletonClassInstance{
private static final StaticInnerClass instance = new StaticInnerClass();
}
//不要同步方法,调用效率高,线程安全且高效
public static StaticInnerClass getInstance(){
return SingletonClassInstance.instance;
}
private StaticInnerClass() {
}
}
总结:
- 外部类没有 static属性,则不会像饿汉式那样立即加载对象。
- 只有真正调用 getinstance(),才会加载静态内部类。加载类时是线程安全的。
- Instance是 static final类型,保证了内存中只有这样一个实例存在,而且只能被赋值一次,从而保证了线程安全性
- 兼备了并发高效调用和延迟加载的优势!
枚举单例
//使用枚举实现单例模式
public enum EnumSingleton {
//这个枚举元素,本身就是单例对象
INSTANCE;
//添加需要的操作
public void singletonOperation(){
}
}
public class Test {
public static void main(String[] args) {
System.out.println(EnumSingleton.INSTANCE == EnumSingleton.INSTANCE);//true
}
}
总结:
- 优点
- 实现简单
- 枚举本身就是单例模式。由JVM从根本上提供保障!避免通过反射和反序列化的漏洞
- 缺点
- 无延迟加载
如何选用最适合的方法?
学习了五种方法之后,那么实际运用中,如何选择合适的方法呢?
根据单例对象的资源消耗程度来选择
当单例对象占用资源少,不需要延时加载时
- 枚举式优于饿汉式
当单例对象占用资源大,需要延时加载时
- 静态内部类式优于懒汉式