看待设计模式,要站在更大的角度(代码重用性、可读性、可扩展性、可靠性、程序高内聚,低耦合)来综合考虑看待,而不是功能实现的角度看待,不要觉得实现一个功能没必要这么麻烦
文章中给出的设计模式类图都是标准的实现方式,并不一定要完全遵守标准,所以只要设计思想符合,一个设计模式有多种实现方式,尤其是看别人源码的时候,不要用标准类图死扣
1. 单例设计模式
- 采取一定方法,保证整个软件系统运行中,只存在一个对象实例,且该类只提供一个取得其对象实例的方法
- 例如Hibernate的SessionFactory,它充当数据存储源的代理,负责创建Session对象,它不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够了,这时就需要单例模式
- 饿汉式单例模式,如果你保证项目中必然会用到这个实例,就可以用,否则会资源浪费
- 懒汉式—双重检查版,如果项目中不一定用到这个实例,为了避免资源浪费,可以用懒汉式,但是多线程高并发场景下,需要双重检查保证线程安全
- 静态内部类实现单例,根据JVM底层运行原理实现
- 枚举类实现单例,好用,推荐
1. 饿汉式单例
- 类被加载,就实例化了实例,一直等着被使用,所以叫饿汉式
- 写法简单,类加载时就完成实例化,避免线程同步问题
- 类加载时就完成实例化,没有达到懒加载(Lazy Loading)效果,如果从始至终从未使用过这个实例,则会造成内存浪费
- 基于classloder(类加载)机制,避免了多线程同步问题,但是,instance(实例)在类加载时就实例化。在单例模式中,大多调用getInstance方法,触发类加载,但是如果有其它静态方法等一系列东西导致类加载,此时虽然我们不想使用这个单例,内存中也初始化了它。
- 这种单例模式可用,但是可能造成内存浪费
1. 静态常量版本
步骤:代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticConstSingleton类 |
---|
- 构造器私有化(保证外部不可以new对象)
- 类的内部创建自己的实例对象(外部不能new,那就自己new)
- 向外暴露一个静态公共方法(外部只能通过这个方法,获取我们自己new的那一个对象)
public class StaticConstSingleton {
public static void main(String[] args) {
StaticConstSingleton singleton = StaticConstSingleton.getSingleton();
StaticConstSingleton singleton2 = StaticConstSingleton.getSingleton();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
System.out.println("两个实例hashCode值分别是多少:"+singleton2.hashCode()+"==========="+singleton.hashCode());
}
private StaticConstSingleton(){
}
private static final StaticConstSingleton singleton = new StaticConstSingleton();
public static StaticConstSingleton getSingleton(){
return singleton;
}
}
2. 静态代码块版本
步骤:代码在com.yzpnb.design_mode.singleton.hungry_singleton包下StaticCodeBlock类 |
---|
- 构造器私有化(保证外部不可以new对象)
- 类的内部创建自己的实例对象(外部不能new,那就自己new)
- 向外暴露一个静态公共方法(外部只能通过这个方法,获取我们自己new的那一个对象)
public class StaticCodeBlock {
public static void main(String[] args) {
StaticCodeBlock singleton = StaticCodeBlock.getInstance();
StaticCodeBlock singleton2 = StaticCodeBlock.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
System.out.println("两个实例hashCode值分别是多少:"+singleton2.hashCode()+"==========="+singleton.hashCode());
}
private StaticCodeBlock(){}
private static StaticCodeBlock staticCodeBlock ;
static{
staticCodeBlock = new StaticCodeBlock();
}
public static StaticCodeBlock getInstance(){
return staticCodeBlock;
}
}
2. 懒汉式
- 懒加载机制,不浪费内存,调用getInstance方法才会new实例
- 但是多线程下需要解决线程安全和同步问题
以下3种懒汉式都是多线程情况下有问题 的,面试官常问,大家最好看看,了解 下面3种实现方式有哪些问题 ,如果不想看 ,直接看正确的双重检查版 |
---|
1. 线程不安全
步骤:代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThredUnsafetySingleton类 |
---|
- 私有化构造函数
- 自己创静态实例,但不初始化
- 提供公共静态方法获取实例,并在这里初始化单例
此方法在多线程场景下,会出现如下问题,所以实际开发多线程程序不要使用这种方式 |
---|
- 当第一个线程进入getInstace中,判断singleton为null,则创建单例
- 此时单例初始化未完成,又一个线程进入,发现singleton没有值,又进行一次初始化。出现多次初始化的问题。
- 又一个线程进入,发现有值,不为null,所以直接拿走实例
- 此时,这个线程拿了一个没有初始化完成的实例对象走了,程序出错
public class ThredUnsafetySingleton {
public static void main(String[] args) {
ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
}
private ThredUnsafetySingleton(){}
private static ThredUnsafetySingleton singleton;
public static ThredUnsafetySingleton getInstance(){
if(singleton == null){
singleton = new ThredUnsafetySingleton();
}
return singleton;
}
}
2. 线程安全,同步方法
步骤:代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySingleton类 |
---|
- 在线程不安全的懒汉式版本基础上,为getInstance方法添加synchronize关键字
会出现如下问题,所以实际开发多线程程序不要使用这种方式 |
---|
- 虽然解决了线程不安全问题
- 但是效率太低,每个线程想要获取类实例时,执行getInstance()方法都要进行同步,但是实例化代码只需要执行一次就够了,后面想获得该实例,直接return即可,但是现在连return都需要同步
public class ThreadSafetySingleton {
public static void main(String[] args) {
ThredUnsafetySingleton singleton = ThredUnsafetySingleton.getInstance();
ThredUnsafetySingleton singleton2 = ThredUnsafetySingleton.getInstance();
System.out.println("两个实例是否相同"+(singleton2 == singleton));
}
private ThreadSafetySingleton(){}
private static ThreadSafetySingleton singleton;
public static synchronized ThreadSafetySingleton getInstance(){
if(singleton == null){
singleton = new ThreadSafetySingleton();
}
return singleton;
}
}
3. 线程安全,同步代码块
步骤:代码在com.yzpnb.design_mode.singleton.idler_singleton包下ThreadSafetySynchroniztionCodeBlockSingleton类 |
---|
- 在线程不安全的懒汉式版本基础上,为getInstance方法中实例化单例的代码添加synchronize关键字
会出现如下问题,所以实际开发多线程程序不要使用这种方式 |
---|
- 虽然解决了效率问题,线程直接return对象时,不需要实例化单例。但是线程不安全问题重新出现了
- 当一个线程进行初始化,此时其它线程判断null进来发现代码加锁,等第一个线程走了,他还是会去执行初始化代码
- 依然会有线程拿一个默认值走的情况发生
public class ThreadSafetySynchroniztionCodeBlockSingleton {
private ThreadSafetySynchroniztionCodeBlockSingleton(){}
private static ThreadSafetySynchroniztionCodeBlockSingleton singleton;
public static ThreadSafetySynchroniztionCodeBlockSingleton getInstance(){
if(singleton == null){
synchronized (ThreadSafetySynchroniztionCodeBlockSingleton.class){
singleton = new ThreadSafetySynchroniztionCodeBlockSingleton();
}
}
return singleton;
}
}
4. 双重检查(重点)
步骤:代码在com.yzpnb.design_mode.singleton.idler_singleton包下DoubleCheck类 |
---|
- 在线程安全,同步代码块的基础上,synchronized代码块中,也加上判断
- 解决线程安全问题
- 效率比直接同步方法高,只有初始化时需要同步,获取实例时,不需要同步
- 当多个线程判断实例为null,进入if执行初始化,因为初始化代码加锁,只有一个能进去
- 此时,加锁代码中,再次判断是否为null,如果是null执行初始化。第一个线程进去会执行初始化,初始化完成,释放锁,第二个线程进去再次判断,发现不为null,不执行初始化
public class DoubleCheck {
private DoubleCheck(){}
private static DoubleCheck singleton;
public static DoubleCheck getInstance(){
if(singleton == null){
synchronized (DoubleCheck.class){
if(singleton == null){
singleton = new DoubleCheck();
}
}
}
return singleton;
}
}
3. 静态内部类
- 外部类被加载时,静态内部类不会被装载
- 当我们使用静态内部类中静态变量或常量时,会加载内部类
- 类加载时,是线程安全的(JVM帮我们保证线程安全,类初始化时,其它线程无法进入)
基于以上3点,我们可以实现一种单例,步骤如下:代码在com.yzpnb.design_mode.singleton.inner_class_singleton包下InnerClassSingleton类 |
---|
- 私有构造
- 静态内部类,创建实例
- 提供公共方法获取单例对象(使用静态内部类变量)
public class InnerClassSingleton {
private InnerClassSingleton(){}
private static class SingletonInstance{
private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
public static InnerClassSingleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
4. 枚举
- 借助JDK1.5中加入的枚举来实现单例模式,不仅可以避免多线程同步问题,还能防止反序列化重新创建新对象
- 是Effective Java作者Josh Bloch提倡的方式
步骤如下:代码在com.yzpnb.design_mode.singleton.emnu_singleton包下EmnuSingleton类 |
---|
- 创建枚举
- 声明属性
- 用就完事了
public class EmnuSingleton {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
instance.say();
}
}
enum Singleton{
INSTANCE;
public void say(){
System.out.println("SAY---");
}
}
2、java源码中哪里用到单例?
- 我们发现只能通过getRuntime()方法获取Runtime实例对象
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/b495cc020b90144130cea15fe5e096cf.png)
- 点进去看逻辑,发现就是简单的懒汉式静态常量版本
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/83090ccbcbca021fb4f9bd1a35fe8636.png)