常用设计模式之单例模式

只创建一个实例:饿汉，懒汉，双重检查，静态内部类，枚举，乐观锁机制

/**
 * @Author: king
 * @Date: 2019/12/24 10:01
 * @Version 1.0
 * 单例模式-饿汉
 */
public class Ehan {
    private final static Ehan ehan = new Ehan();
    private Ehan(){

    }
    public static Ehan getInstance(){
        return ehan;
    }
}

/**
 * @Author: king
 * @Date: 2019/12/23 13:15
 * @Version 1.0
 * 单例模式-同步懒汉
 * a） 将被实现的类的构造方法设计成private的。
 * b） 添加此类引用的静态成员变量，并为其实例化。
 * c）  在被实现的类中提供公共的CreateInstance函数，返回实例化的此类,就是b中的静态成员变量。
 */
public class Singleton {
    private static Singleton singleton;
    private Singleton(){
        /***
         * 单例构造方法私有的
         */
    }

    /***
     * 设置同步方法
     * @return 实例
     */
    public static synchronized Singleton createSingleton(){
        if (singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }

    public void print(String msg){
        System.out.println(msg);
    }
}

/**
 * @Author: king
 * @Date: 2019/12/24 10:03
 * @Version 1.0
 * 单例模式-双重检查懒汉
 */
public class CheckedSingleton {
    private static CheckedSingleton checkedSingleton;
    private CheckedSingleton(){}
    public static CheckedSingleton getInstance(){
        if (checkedSingleton==null){
            synchronized (CheckedSingleton.class){
                if (checkedSingleton==null) {
                    checkedSingleton = new CheckedSingleton();
                }
            }
        }
        return checkedSingleton;
    }
}

/**
 * @Author: king
 * @Date: 2019/12/24 10:06
 * @Version 1.0
 * 单例模式-静态内部类
 */
public class InnerSingleton {
    private InnerSingleton() {
    }

    private static class SingletonInstance {
        private final static InnerSingleton singletonInstance = new InnerSingleton();
    }

    public static InnerSingleton getInstance() {
        return SingletonInstance.singletonInstance;
    }
}

/**
 * @Author: king
 * @Date: 2019/12/24 10:24
 * @Version 1.0
 * 单例模式-枚举
 */
public enum EnumSingleton {
    SINGLETON_INSTANCE;
    public void print(String msg){
        System.out.println(msg);
    }
}

import java.util.concurrent.atomic.AtomicReference;

/**
 * @Author: king
 * @Date: 2019/12/24 10:43
 * @Version 1.0
 * 单例模式-乐观锁
 * 优：不需要使用传统的锁机制来保证线程安全,CAS是一种基于忙等待的算法,依赖底层硬件的实现,相对于锁它没有线程切换和阻塞的额外消耗,可以支持较大的并行度
 * 缺：如果忙等待一直执行不成功(一直在死循环中),会对CPU造成较大的执行开销。另外，如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象创建，很可能导致内存溢出。
 */
public class CASSingleton {
    private static final AtomicReference INSTANCE = new AtomicReference();

    private CASSingleton() {
    }

    public static CASSingleton getInstance() {
        for (; ; ) {
            CASSingleton casSingleton = (CASSingleton) INSTANCE.get();
            if (casSingleton != null) {
                return casSingleton;
            }
            casSingleton = new CASSingleton();
            if (INSTANCE.compareAndSet(null, casSingleton)) {
                return casSingleton;
            }
        }
    }
    public void print(String msg){
        System.out.println(msg);
    }
}