设计模式-单例模式的实现与应用

1.饿汉式单例模式

饿汉式-就是不管三七二十一，只要初始化类便创建对象；

但是有个弊端就是如果没有调用创建对象的方法，那么它也会创建对象，会造成内存浪费。

如下：

public class HungrySingle {

    private HungrySingle(){

    }
    //初始化对象
    private final static HungrySingle HUNGRY_SINGLE = new HungrySingle();
    //创建对象的方法
    public static HungrySingle getInstance(){
        return HUNGRY_SINGLE;
    }
}

2.懒汉式单例模式

懒汉式-需要的时候再进行创建对象，需要保证原子性，注意线程安全（双重检测）

划重点！！！！工作中经常使用的方法

public class LazySingle {


    private LazySingle() {
        System.out.println(Thread.currentThread().getName() + "___ok");
    }

    //保证原子性
    private volatile static LazySingle LAZY_SINGLE;

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

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazySingle.getInstance();
            }).start();
        }
    }
}

3.静态内部类实现

内部类对本类的对象进行实例化，创建对象的方法直接返回内部类示例的对象即可，保证了线程安全

public class FinalSingle {

    private FinalSingle(){
        System.out.println(Thread.currentThread().getName()+"_ok");
    }

    private static class instance{
        private static final FinalSingle finalSingle = new FinalSingle();
    }

    private static final FinalSingle getInstance(){
        return instance.finalSingle;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(FinalSingle::getInstance).start();
        }

    }
}

4.枚举实现

不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化

这种方法是官方最推荐的方法，但是工作中使用并不常见

public enum SingleEnum {

    INSTANCE;

    private Resource resource;

    SingleEnum() {
        resource = new Resource();
    }

    public Resource doSomething() {
        return resource;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(SingleEnum.INSTANCE::doSomething).start();
        }

    }

}
class Resource {

    public Resource() {
        System.out.println(Thread.currentThread().getName() + " recource init");
    }
}