设计模式之单例模式的八种实现方式

单例模式

​ 定义：采取一定的方法保证在整个软件系统中，某个类只能存在一个对象实例，并且只提供一个取得其对象实例的方法。

1.饿汉式（静态变量）

/*
*   饿汉式（静态变量）
*   优点：简单，在类装载的时候就完成实例化，避免了线程同步问题
*   缺点：没有起到懒加载的效果，可能造成内存的浪费
* */
public class SingleTon01 {
    private static SingleTon01 instance = new SingleTon01();

    private SingleTon01 () {
    }

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

2.饿汉式（静态代码块）

/*
*   饿汉式（静态代码块）
* */
public class SingleTon02 {
    private SingleTon02() {}

    private static SingleTon02 instance;

    static {
        instance = new SingleTon02();
    }

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

3.懒汉式（线程不安全）

/*
    懒汉式（线程不安全）
    优点：起到了懒加载的效果，但只能在单线程环境下使用
    缺点：线程不安全
    结论：实际工作中，不要使用这种方式
* */
public class SingleTon03 {
    private static SingleTon03 instance;

    private SingleTon03 () {}

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

4.懒汉式（线程安全）

/*
* 懒汉式（线程安全）
* 优点：解决了线程安全问题
* 缺点：效率太低了，每个线程在获取类的实例时都要执行同步方法，但事实上这个方法只执行一次就够了
* */
public class SingleTon04 {
    private static SingleTon04 instance;

    private SingleTon04() {
    }

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

5.懒汉式（线程安全，同步代码块）

/*
* 懒汉式（线程安全，同步代码块）
* 其实线程不安全，不推荐
* */
public class SingleTon05 {
    private static SingleTon05 instance;

    private SingleTon05() {}

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

6.双重检查

/*
*  双重检查
*  优点：线程安全，懒加载，效率高，推荐使用
* */
public class SingleTon06 {

    //volatile 关键字的作用：保证可见性，防止指令重排
    private static volatile SingleTon06 instance;

    private SingleTon06() {}

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

7.静态内部类

/*
* 静态内部类
* 特点：1.外部类被装载的时候静态内部类不会立即被装载
* 2.当调用getInstance方法时，会导致静态内部类被装载，且只会装载一次，在装载时线程是安全的，推荐使用
* */
public class SingleTon07 {
    private static SingleTon07 instance;

    private static class SingleTonInstance {
        private static final SingleTon07 INSTANCE = new SingleTon07();
    }

    public static SingleTon07 getInstance() {
        return SingleTonInstance.INSTANCE;
    }
}

8.枚举

/*
* 枚举
* 优点：能避免多线程同步问题，而且能防止反序列化重新创建新的对象，推荐使用
* */
enum SingleTon08 {
    INSTANCE;
}