23种设计模式-单例

概念

保证一个类在整个应用程序周期中只会被创建一次，并提供一个全局的访问点

分类

• 饿汉式
• 懒汉式
• 双重校验
• 静态内部类
• 枚举类

1. 饿汉式

该种方法如同一个饥饿的流浪汉一样，遇到食物就会第一时间去吃了，饿汉式单例就是在类加载的时间进行对象的创建，而后续就会拿到同一个对象

实现：

//饿汉式
public class SingleDemo1 {
    //加载类的时候进行创建
    private static SingleDemo1 singleDemo1 = new SingleDemo1();
    private SingleDemo1() {
        System.out.println("创建->饿汉式单例");
    }

    public static SingleDemo1 getInstance() {
        System.out.println("获得->饿汉式单例");
        return singleDemo1;
    }
}

调用：

    public static void main(String[] args) {
        System.out.println("main方法");
        System.out.println("--------------------------");
        System.out.println("第一次调用----------------------------");
        SingleDemo1.getInstance();
        System.out.println("第二次调用----------------------------");
        SingleDemo1.getInstance();
        System.out.println("第三次调用----------------------------");
        SingleDemo1.getInstance();
    }

输出：

main方法
--------------------------
第一次调用----------------------------
创建->饿汉式单例
获得->饿汉式单例
第二次调用----------------------------
获得->饿汉式单例
第三次调用----------------------------
获得->饿汉式单例

从上面例子就可以看出，会在调用 getInstance（）方法之前就会对创建好该类对象，而后面每一次拿到的都是第一次创建的对象

2. 懒汉式

可以把这种方式比喻成在家我的，只有没人叫我扫地，我绝对不会动一下扫把，能拖就拖。懒汉式单例就是需要等主动调用全局访问点时才会去创建对象。

实现：

//懒汉式
public class SingleDemo2 {
    private static SingleDemo2 instance;
    private SingleDemo2() {
        System.out.println("初始化");
    }

    public static synchronized SingleDemo2 getInstance() {
        if (instance == null) {
            instance = new SingleDemo2();
        }
        System.out.println("获取实例");
        return instance;
    }
}

调用：

    public static void main(String[] args) {
        System.out.println("main方法");
        System.out.println("--------------------------");
        System.out.println("第一次调用----------------------------");
        SingleDemo2.getInstance();
        System.out.println("第二次调用----------------------------");
        SingleDemo2.getInstance();
        System.out.println("第三次调用----------------------------");
        SingleDemo2.getInstance();
    }

输出：

main方法
--------------------------
第一次调用----------------------------
初始化
获取实例
第二次调用----------------------------
获取实例
第三次调用----------------------------
获取实例

 可以看到这种单例是需要主动去调用getInstance（）方法才会去创建一个实例，且每次调用都是去拿的第一次创建的实例，如果在多线程的情况下是需要加上synchronized 以保证线程安全。

3. 双重校验

这种主要是在懒汉式的基础上将锁的颗粒度提高，懒汉式的synchronized是加在方法上，意思是每次调用方法的时候会锁住整个方法，双重校验在懒汉式上这一方面做了优化。

实现：

//双重校验
public class SingleDemo2 {
    private static SingleDemo2 instance;

    private SingleDemo2() {
        System.out.println("初始化");
    }

    public static SingleDemo2 getInstance() {
        if (instance == null) {
            synchronized (SingleDemo2.class) {
                if (instance == null) {
                    instance = new SingleDemo2();
                }
            }
        }
        System.out.println("获取实例");
        return instance;
    }
}

从代码上可以看到，synchronized的从锁住方法移动到锁住具体创建的那条语句，这样的化只要不是第一次创建，多线程时就不会将这个方法锁住。

4. 静态内部类（线程安全）

静态内部类在懒加载的情况下借助JVM类加载机制保证线程安全

实现：

//静态内部类
public class SingleDemo4 {

    private static class InnerClass{
        private static final SingleDemo4 instance = new SingleDemo4();
    }
    private SingleDemo4(){
    }
    public static SingleDemo4 getInstance(){
        return InnerClass.instance;
    }
}

从代码上可以看出，整个类里面并没有synchronized，但是确保证了线程的安全，当用户一次调用getInstance()的时候才会创建一个实例，也实现了懒加载。