java设计模式--单例模式

单例模式：在用户需要使用使用一个对象，不论在哪里使用，都是同一个对象
1、饿汉模式（类完成加载就完成初始化）

public class Mgr01 {
    //私有化构造方法，无法new出对象
    private Mgr01(){}

    //新建final对象
    private static final Mgr01 INSTANCE = new Mgr01();

    //开放获取final对象的方法
    public static  Mgr01 getInstance(){
        return INSTANCE;
    }
}

2、懒汉模式（在使用的时候就完成初始化）
问题：多线程访问进行初始化的时候，线程不安全；

public class Mgr02 {
    //私有化构造方法，无法new出对象
    private Mgr02(){}

    //新建对象
    private static  Mgr02 INSTANCE ;

    //开放获取对象的方法
    public static Mgr02 getInstance(){
    //第一次调取之后，完成初始化
        if(INSTANCE==null){
            INSTANCE = new Mgr02();
        }
        return INSTANCE;
    }
}

3、懒汉模式加锁
问题：效率下降

public class Mgr03 {
    //私有化构造方法，无法new出对象
    private Mgr03(){}

    //新建对象
    private static Mgr03 INSTANCE ;

    //开放获取对象的方法，并加锁
    public static synchronized Mgr03 getInstance(){
    //第一次调取之后，完成初始化
        if(INSTANCE==null){
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }
}

4、懒汉模式之双重检查提高效率

//加锁之双重检查提高效率
public class Mgr04 {
    //私有化构造方法，无法new出对象
    private Mgr04(){}

    //新建f对象
    private static Mgr04 INSTANCE ;

    //开放获取对象的方法
    public static  Mgr04 getInstance(){
    //第一次调取之后，完成初始化
        if(INSTANCE==null){
            //加锁之双重检查
            synchronized (Mgr04.class){
                if(INSTANCE==null){
                    INSTANCE = new Mgr04();
                }
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }
}

5、懒加载之内部静态类加载（内部静态类，在需要的时候进行初始化，jvm保证线程安全）

//内部静态类，在需要的时候进行初始化，jvm保证线程安全
public class Mgr05 {
    //私有化构造方法，无法new出对象
    private Mgr05(){}

    //建立内部类
    private static class Mgr05Holder{
        private final static Mgr05 INSTANCE = new Mgr05();
    }

    //开放获取对象的方法
    public static Mgr05 getInstance(){
    //第一次调取之后，完成初始化
        return Mgr05Holder.INSTANCE;
    }
}

6、单例模式之java创始人写法（枚举）

//枚举法
public enum Mgr06 {
    INSTANCE;
}