Java-单例-设计模式（一）

普通懒汉

/**
 * @author ctl
 * @date 2021/1/10
 * 单例模式 懒汉，非线程安全
 */
public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

线程安全懒汉

/**
 * @author ctl
 * @date 2021/1/10
 * 懒汉，线程安全，效率低下
 */
public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

饿汉

/**
 * @author ctl
 * @date 2021/1/10
 * 饿汉，加载时就创建，无法做到懒加载，消耗资源
 */
public class Singleton3 {

    private static Singleton3 instance = new Singleton3();

    private Singleton3() {
    }

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

/**
 * @author ctl
 * @date 2021/1/10
 * 饿汉，也是加载时就创建，跟上一种区别不大
 */
public class Singleton4 {

    private static Singleton4 instance = null;

    static {
        instance = new Singleton4();
    }

    private Singleton4() {
    }

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

静态内部类

/**
 * @author ctl
 * @date 2021/1/10
 * 静态内部类，可以做到懒加载
 */
public class Singleton5 {

    private static class SingletonHolder {
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    private Singleton5() {
    }

    public static final Singleton5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

枚举

/**
 * @author ctl
 * @date 2021/1/10
 * 枚举，写法简单，但使用不多
 */
public enum Singleton6 {

    INSTANCE;

    public void whateverMethod() {
    }
}

双重检查

/**
 * @author ctl
 * @date 2021/1/10
 * 双重检查
 */
public class Singleton7 {

	// volatile避免指令重排
    private volatile static Singleton7 instance;

    private Singleton7() {

    }

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

总结

其实还有很多变种的写法，很难说哪一种写法就是最完美的，了解原理即可，实际业务中可以根据不同的场景来做取舍和扩展，或者直接使用成熟的框架来管理，避免重复造轮子。