单例模式

单例模式的八种方式

饿汉式(静态常量)
饿汉式(静态代码块)
懒汉式(线程不安全)
懒汉式(线程安全，同步方法)
懒汉式(线程安全，同步代码块)
双重检查
静态内部类
枚举

八种方式详解

饿汉式(静态常量)

步骤

构造函数私有化
类的内部创建对象
向外暴露一个静态的公共方法

代码实现


public class BaseSingleton {
    //加载该类时，单例就会自动被创建
    private static BaseSingleton baseSingleton = new BaseSingleton();

    //构造函数设置有私有函数，禁止他人创建实例
    private BaseSingleton() {

    }

    //通过静态方法获得创建的单例
    public static BaseSingleton newInstance() {
        return baseSingleton;
    }
}

优缺点

优点:写法简单，在类装载的时候就完成了实例化，避免了线程同步的问题
缺点：在类装载的时候就完成了实例化，没有达到懒加载的效果，如果从始至终都没有使用过这个实例，就会造成内存的浪费

饿汉式(静态代码块)

步骤

构造函数私有化
类的内部声明静态变量
静态代码块实现对象的初始化
向外暴露一个静态的公共方法

代码实现

public class BaseSingleton {
    //加载该类时，单例就会自动被创建
    private static BaseSingleton baseSingleton;

    static {
        baseSingleton = new BaseSingleton();
    }

    //构造函数设置有私有函数，禁止他人创建实例
    private BaseSingleton() {

    }

    //通过静态方法获得创建的单例
    public static BaseSingleton newInstance() {
        return baseSingleton;
    }
}

优缺点

和静态常亮一样，写法简单，在类装载的时候就完成了实例化，避免了线程同步的问题
在类装载的时候就完成了实例化，没有达到懒加载的效果，如果从始至终都没有使用过这个实例，就会造成内存的浪费

懒汉式(线程不安全)

步骤

构造函数私有化
类的内部声明静态变量
向外暴露一个静态的公共方法，在调用该方法时，判断对象是否存在，不存在则创建，存在则直接返回

代码实现

public class LazySingleton {

    //类加载时，先不自动创建实例，将单例的引用赋值为null
    private static LazySingleton lazySingleton = null;

    //构造函数私有化，防止他人创建实例
    private LazySingleton() {
    }

    //需要时调用newInstance 创建实例
    public static LazySingleton newInstance() {
        //先判断是否为空，避免重复创建
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

优缺点

起到了懒加载的作用，但是只能在单线程下使用
如果在多线程下，一个线程进入了if (lazySingleton == null)中，还未来得及在往下执行，线程被挂起，另一个线程也通过了这个判断语句，这个时候就会产生多个实例，所以多线程下不可以用这种方式

懒汉式(线程安全，同步方法)

步骤

构造函数私有化
类的内部声明静态变量
向外暴露一个同步(synchronized)的静态的公共方法，在调用该方法时，判断对象是否存在，不存在则创建，存在则直接返回

代码实现

public class LazySingleton {

    //类加载时，先不自动创建实例，将单例的引用赋值为null
    private static LazySingleton lazySingleton = null;

    //构造函数私有化，防止他人创建实例
    private LazySingleton() {
    }

    //需要时调用newInstance 创建实例，方法同步synchronized
    public static synchronized LazySingleton newInstance() {
        //先判断是否为空，避免重复创建
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

优缺点

解决了线程不安全的问题
效率低下，每个线程在想获得实例的时候，执行newInstance()方法都要进行同步，而这个方法只执行一次实例化代码就够了，后面想要获得该类的实例，直接return就可以，方法进行同步效率过于低下

懒汉式(线程安全，同步代码块)

步骤

构造函数私有化
类的内部声明静态变量
向外暴露一个静态的公共方法，在调用该方法时，判断对象是否存在，不存在则创建(使用同步代码块)，存在则直接返回

代码实现

public class LazySingleton {
    //类加载时，先不创建对象，单例的引用先赋值未null
    private static LazySingleton LazySingleton = null;

    //构造函数私有化，防止他人创建实例
    private LazySingleton() {
    }

    public static LazySingleton newInstance2() {
        synchronized (LazySingleton.class) {
            if (LazySingleton == null) {
                LazySingleton = new LazySingleton();
            }
        }
        return LazySingleton;
    }

}

优缺点

这种方式和同步方法的方式类似，只是为了减少同步的范围将同步方法缩小到具体的实例方法处,效率问题没有降低

双重检查

步骤

构造函数私有化
类的内部声明静态变量
向外暴露一个静态的公共方法，在调用该方法时，判断对象是否存在，存在则直接返回，不存在的话，加入锁代码，锁代码中再次判断对象是否存在，不存在的话再进行对象的实例化

代码实现

/**
 * @Classname LazySingleton
 * @Description 双重校验锁，在同步锁的基础上，添加一层if判断，若单例已经创建，则不需要执行加锁操作就可以获取实例，从而提高性能。
 * @Date 19-2-1 下午2:34
 * @Created by yujuan
 */
public class LazySingleton {
    private static LazySingleton LazySingleton;

    private LazySingleton() {
    }

    public static LazySingleton newInstance() {
        //加入双重校验
        //校验锁1 第一个if
            //作用：若单例已经创建，则直接返回创建的单例对象，无需在进行加锁操作
        if (LazySingleton == null) {
            //校验锁2 第二个if
                //作用：防止多次创建单例问题
                //原理：
                    //1、线程A调用newInstance 运行到2位置时，此时线程B也调用了newInstance
                    //2、因线程A还没有执 LazySingleton = new LazySingleton() ,此时lazySingleton为空，因此线程B能突破第一层if判断，运行到1synchronized中的A执行完成
                    //3、当线程A释放同步锁的时候，单例已经创建，LazySingleton不为空
                    //4、此时线程B从1开始位置执行到2时，此时第二层if判断不成立，不会再次创建多余的实例
            synchronized (LazySingleton.class) {
                if (LazySingleton == null) {
                    LazySingleton = new LazySingleton();
                }
            }
        }
        return LazySingleton;

    }
}

优缺点

线程安全
延迟加载，解决了之前单例模式懒加载效率低下的问题

静态内部类

步骤

构造函数私有化
声明一个静态内部类，在类的内部完成实例的创建
向外暴露一个静态的公共方法，提供对象的实例

代码实现

/**
 * @Classname InnerClassSingleton
 * @Description 根据静态内部类的特性，同时解决了按需加载，线程安全的问题，同时实现简单
 * 1、在静态内部类中创建单例，在装载该内部类的时候才会去创建单例
 * 2、线程安全，类是由JVM加载，而JVM只会加载一遍，保证只有一个实例
 * @Date 19-2-1 下午2:45
 * @Created by yujuan
 */
public class InnerClassSingleton {
    //创建静态内部类
    private static class InnerClassSingleton2 {
        //在静态内部类中创建实例
        private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
    }
    //私有构造函数
    private InnerClassSingleton() {
    }
    //延迟加载，按需创建
    public static InnerClassSingleton newInstance() {
        return InnerClassSingleton2.innerClassSingleton;
    }
    //调用过程说明：
        //1、外部调用类的newInstance()
        //2、自动调用InnerClassSingleton2.innerClassSingleton 得到初始化
            //2.1 此时单例类InnerClassSingleton2 得到初始化
            //2.2 而该类在装载&被初始化时，会初始化它的静态域，从而创建单例
            //2.3 由于是静态域，因此只会JVM加载一次，java虚拟机保证的线程的安全性
        //3、最终只创建了一个单例
}

优缺点

采用类装载的机制来保证初始化实例时只有一个线程
静态内部类在InnerClassSingleton类被装载时不会立即实例化，而是在需要的实例化的时候，调用newInstance方法，才会进行对内部静态类的装载，从而完成对Singleton的实例化
类的静态属性只会在第一次加载类的时候j进行初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
避免的线程不安全的问题，利用静态内部类特点实现延迟加载，效率高

枚举

步骤

1.创建一个枚举类,添加枚举来实现单例模式

代码实现

public enum enumSingleton {
    INSTANCE;
}

优缺点

避免多线程同步的问题，可以防止反序列化重新创建新的对象

AtomicReference

使用AtomicReference 修饰对象,通过CAS的方式实现单例模式参考阿里云开发者社区

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>(); 

    private Singleton() {}

    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }

            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }
}