设计模式05-单例模式

一、介绍

在程序运行期间确保某个类只有一个对象

二、饿汉式

tip：非常饿，所以要快速创建

public class HungrySingle{
private static HungrySingle instance = new HungrySingle();
    private HungrySingle(){

    }

    public static HungrySingle getInstance() {
        return instance;
    }
}

优点：线程安全，容易实现，没有加锁，执行效率高
缺点：浪费内存，不能从外部传入参数

三、懒汉式

tip：这里的懒指的是懒加载。
饿汉式由于不能传参，所以需要懒汉式单例，由外部传入参数进行初始化。

public class LazySingle {
    private static LazySingle instance = null;
    private int type;

    private LazySingle(int type) {
        this.type = type;
    }

    public static LazySingle getInstance(int type) {
        if(instance == null){
            instance = new LazySingle(type);
        }
        return instance;
    }
}

优点：可以传参，容易实现，没有加锁，执行效率高，懒加载（使用时才创建）
缺点：线程不安全

四、双重校验锁

饿汉式虽然执行效率高，但是无法传参，不使用也占用内存。
懒汉式可以解决传参的问题，但是线程不安全，如果加锁了会影响效率。
双重校验锁可以进行双重校验，如果已经实例化就直接返回，提高效率，并且线程安全。

public class DoubleCheckSingle {
    int type;
    private static volatile DoubleCheckSingle instance;
    private DoubleCheckSingle(int type){
        this.type = type;
    }

    public static DoubleCheckSingle getInstance(int type){
        if(instance == null){
            synchronized (DoubleCheckSingle.class){
                if(instance == null){
                    instance = new DoubleCheckSingle(type);
                }
            }
        }
        return instance;
    }
}

volatile关键字保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
禁止进行指令重排序。（实现有序性）

优点：可以传参，线程安全，效率高
缺点：实现较复杂

五、静态内部类

与懒汉式不同，饿汉式在类加载时就已经创建一个实例。静态内部类的方式会在调用getInstance()方法时才创建实例，既达到懒加载的目的，又能保证线程安全。

public class InnerSingle {
    private InnerSingle() {

    }

    public static InnerSingle getInstance() {
        return Holder.instance;
    }

    static class Holder {
        private static InnerSingle instance = new InnerSingle();
    }
}

优点：懒加载，线程安全
缺点：不能传参，实现较复杂

六、枚举

public enum EnumSingle {
    INSTANCE;
    
    private EnumSingle(){
        
    }
}

优点：实现简单，线程安全
缺点：无法传参