设计模式03: 单例模式

介绍

• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。
• 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。

饿汉式（静态常量）

步骤

1. 构造器私有化
2. 类的内部创建对象
3. 向外暴露获取单例对象的方法

代码

public class SingleTon01{
    
    
    private SingleTon01(){
    
    }
    private static SingleTon01 singleTon01 = new SingleTon01();
    public SingleTon01 getInstance(){
    
    
        return singleTon01;
    }
}

优缺点

饿汉式（静态代码块）

步骤

1. 私有化构造器
2. 类的内部创建静态私有化变量
3. 使用静态代码块初始化对象
4. 对外暴露获取单例的静态方法

代码

public class SingleTon02{
    
    
    private SingleTon02(){
    
    }
    private static SingleTon02 singleTon02;
    static {
    
    
        singleTon02 = new SingleTon02();
    }
    public static SingleTon02 getInstance(){
    
    
        return singleTon02;
    }
}

优缺点

懒汉式（线程不安全）

步骤

1. 私有化构造器
2. 创建私有化静态变量
3. 对外暴露获取实例的方法，若实例为空，创建对象；不为空，直接返回。

代码

public class SingleTon03 {
    
    
    private SingleTon03(){
    
    }
    private static SingleTon03 singleTon03;
    public static SingleTon03 getInstance(){
    
    
        if (singleTon03 == null){
    
    
            singleTon03 = new SingleTon03();
        }
        return singleTon03;
    }
}

优缺点

懒汉式（线程安全，同步方法）

步骤

在前一种懒汉式方法的过程中的获取实例方法中添加synchronized关键字

代码

public class SingleTon04{
    
    
    private SingleTon04(){
    
    }
    private static SingleTon04 singleTon04;
    public static synchronized SingleTon04 getInstance(){
    
    
        if (singleTon04 == null){
    
    
            singleTon04 = new SingleTon04();
        }
        return singleTon04;
    }
}

优缺点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XzXD11Fo-1602674001991)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20201005114424870.png)]

懒汉式（线程不安全，同步代码块）

步骤

在第一种饿汉式的if判断内代码用同步代码块将创建一个实例的语句包围

代码

public class SingleTon05{
    
    
    private SingleTon05(){
    
    }
    private static SingleTon05 singleTon05;
    public static SingleTon05 getInstance(){
    
    
        if (singleTon05 == null){
    
    
            synchronized(Singleton.class){
    
    
                singleTon05 = new SingleTon05();
            }
            
        }
        return singleTon03;
    }
}

优缺点

双重检查

步骤

在前一种方式的基础上，在创建实例前再用if语句判断实例是否已创建

代码

public class Singleton6 {
    
    
    private Singleton6(){
    
    }
    private static volatile Singleton6 singleton6;
    public static Singleton6 getInstance(){
    
    
        if(singleton6 == null){
    
    
            synchronized (Singleton6.class){
    
    
                if(singleton6 == null){
    
    
                    singleton6 = new Singleton6();
                }
            }
        }
        return singleton6;
    }
}

优缺点

静态内部类实现

步骤

创建静态内部类，在类里进行实例的创建

代码

public class Singleton7 {
    
    
    private Singleton7(){
    
    }
    private static class SingletonInstance{
    
    
        private static final Singleton7 SINGLETON_7 = new Singleton7();
    }
    public static Singleton7 getInstance(){
    
    
        return SingletonInstance.SINGLETON_7;
    }
}

优缺点