设计模式——单例模式

定义：

采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

---

饿汉式（静态常量法）

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:16
 */
public class SingletonHungry {
    //构造器私有化
    private SingletonHungry() {
    }
    //本类内部创建对象实例
    private final static SingletonHungry instance = new SingletonHungry();
    //提供一个公有的静态方法，返回实例对象
    public static SingletonHungry getInstance() {
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:13
 */
public class SingletonTest {

    public static void main(String[] args) {
        SingletonHungry singletonHungry1 = SingletonHungry.getInstance();
        SingletonHungry singletonHungry2 = SingletonHungry.getInstance();
        System.out.println(singletonHungry1 == singletonHungry2);
    }

}

执行结果

 

优缺点：

1. 写法简单，类加载时完成对象创建，线程安全
2. 可能造成内存浪费：已实例化的对象可能一直不被调用

饿汉式（静态代码块） 

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry2 {
    //构造器私有化
    private SingletonHungry2() {
    }
    private static SingletonHungry2 instance;
    //在静态代码块中完成对象创建
    static {
        instance = new SingletonHungry2();
    }
    //提供一个公有的静态方法，返回实例对象
    public static SingletonHungry2 getInstance() {
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

    public static void main(String[] args) {
        SingletonHungry2 singletonHungry1 = SingletonHungry2.getInstance();
        SingletonHungry2 singletonHungry2 = SingletonHungry2.getInstance();
        System.out.println(singletonHungry1 == singletonHungry2);
    }

}

 执行结果

优缺点：

1. 写法简单，类加载时完成对象创建，线程安全
2. 可能造成内存浪费：已实例化的对象可能一直不被调用

懒汉式（同步方法） 

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry3 {
    //构造器私有化
    private SingletonHungry3() {
    }
    private static SingletonHungry3 instance;
    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static synchronized SingletonHungry3 getInstance() {
        if(instance == null) {
            instance = new SingletonHungry3();
        }
        return instance;
    }
}

/**
 * @create fanzixia 调用方法类
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

    public static void main(String[] args) {
        SingletonHungry3 singletonHungry1 = SingletonHungry3.getInstance();
        SingletonHungry3 singletonHungry2 = SingletonHungry3.getInstance();
        System.out.println(singletonHungry1 == singletonHungry2);
    }

}

 执行结果

优缺点：

1. 使用时才创建对象，节省内存开销，线程安全
2. getInstance方法每次只能一个线程通过，效率低

 懒汉式（双重检查）

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry4 {
    //构造器私有化
    private SingletonHungry4() {
    }
    private static SingletonHungry4 instance;
    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static SingletonHungry4 getInstance() {
        if (instance == null) {
            synchronized (SingletonHungry4.class) {
                if (instance == null) {
                    instance = new SingletonHungry4();
                }
            }
        }
        return instance;
    }
}

/**
 * @create fanzixia 调用方法
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

    public static void main(String[] args) {
        SingletonHungry4 singletonHungry1 = SingletonHungry4.getInstance();
        SingletonHungry4 singletonHungry2 = SingletonHungry4.getInstance();
        System.out.println(singletonHungry1 == singletonHungry2);
    }

}

 执行结果

优缺点：

1. 使用时才创建对象，节省内存开销，线程安全
2. 只有刚开始getInstance方法只允许一个线程通过，对象初始化成功之后可以多线程通过，既保证线程又提高了效率

  懒汉式（静态内部类）

/**
 * @create fanzixia 实体类
 * @time 2022/4/25 23:13
 */
public class SingletonHungry5 {
    //构造器私有化
    private SingletonHungry5() {
    }
    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final SingletonHungry5 INSTANCE = new SingletonHungry5();
    }
    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized SingletonHungry5 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

/**
 * @create fanzixia 调用方法
 * @time 2022/4/25 23:16
 */
public class SingletonTest {

    public static void main(String[] args) {
        SingletonHungry5 singletonHungry1 = SingletonHungry5.getInstance();
        SingletonHungry5 singletonHungry2 = SingletonHungry5.getInstance();
        System.out.println(singletonHungry1 == singletonHungry2);
    }

}

 执行结果

优缺点：

1. 利用静态内部类在外部类初始化的时候并不会初始化的特点，解决了内存浪费问题
2. 当第一次调用是，静态内部类会被初始化，类初始化的时候是线程安全的
3. 类加载后不会被第二次加载，保证了效率 

 分享总结 | 如有侵权请联系删除