单例模式

单例模式

什么是单例模式

定义：保证每个类仅有一个实例，并给外部提供一个访问它的全局访问点。

由类本身来提供外部访问这个类的实例的方法，就实现了单例模式。

Java单中模式有几种实现方式：分别是饿汉式、懒汉式、枚举式、静态内部类实现模式、通过反射实现。

单例模式可以牵扯到很多东西，比如 多线程是否安全，是否懒加载，性能等。

选用原则：

1. 单例对象 占用资源少，不需要延时加载，枚举 好于 饿汉
2. 单例对象 占用资源多，需要延时加载，静态内部类 好于 懒汉式

下面对五中方法进行一一详解

1. 饿汉式

public class Hungry{
    private Hungry（）{}
    private final static Hungry hungry = new Hungry();
    public static Hungry getInstance() {
        return hungry;
    }
}

饿汉式是最简单的单例模式的写法，保证了线程的安全，在很长的时间里，我都是饿汉模式来完成单例的。但是饿汉式会在内存中保存暂时用不到的对象，我们希望只有盗用方法才会初始化对象，所以就会出现懒汉式单例模式。

2. 懒汉式

DCL懒汉式的单例，保证了线程的安全性，又达到了只有在用到的时候，才会去初始化，调用效率也比较高

public class LazyMan {
    private LazyMan() {
    }
    private static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

这种方法在

lazyMan = new LazyMan();

时候要进行三个步骤：分配内存、执行构造方法、指向地址。并没有达到原子性。导致了线程的不安全。

可以在上面DCL单例模式增加一个volatile关键字来避免指令重排：

public class LazyMan {
    private LazyMan() {
    }

    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

3. 静态内部类

如果还是在类中定义static对象，并直接初始化，可以将对象放进静态内部类中，这样既保证了线程的安全性，又满足了懒汉式。

public class SingletonDemo3 {
 
  private static class SingletonClassInstance{
   private static final SingletonDemo3 instance=new SingletonDemo3();
     }
     private SingletonDemo3(){}
     public static SingletonDemo3 getInstance(){
     return SingletonClassInstance.instance;
     }      
}

静态内部类实现模式优点：线程安全，调用效率高，可以延时加载。

4. 枚举类

枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）。枚举是目前最推荐的单例模式的写法，因为足够简单，不需要开发自己保证线程的安全，同时又可以有效的防止反射破坏我们的单例模式

public enum EnumSingleton {
    instance;
    public EnumSingleton getInstance(){
        return instance;
    }
}

public enum SingletonDemo4 {
    //枚举元素本身就是单例
    INSTANCE;
    //添加自己需要的操作
    public void singletonOperation(){     
    }
}

5. Double CheckLock实现单例

DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）具体代码实现如下：

public class SingletonDemo {
    private volatile static SingletonDemo SingletonDemo;

    private SingletonDemo() {
    }
    public static SingletonDemo newInstance() {
        if (SingletonDemo == null) {
            synchronized (SingletonDemo.class) {
                if (SingletonDemo == null) {
                    SingletonDemo = new SingletonDemo();
                }
            }
        }
        return SingletonDemo;
    }
}