单例设计模式

单例设计模式分为懒汉式和饿汉式，懒汉式具有延迟加载的特性。
将构造函数声明为private，禁止外部创建对象，然后内部创建一个私有的本身对象，再创建一个静态公有的函数供外部获取内部的单个私有对象。
饿汉式：

public class SingletonDemo1 {

    //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
    private static SingletonDemo1 instance = new SingletonDemo1();  

    private SingletonDemo1(){
    }

    //方法没有同步，调用效率高！
    public static SingletonDemo1  getInstance(){
        return instance;
    }

}

懒汉式：
package Singleton_Pattern;
/**
* 懒汉式单例，线程不安全
* 原因：如一个线程A执行到sin = new　Singleton(),但是还没有获取对象，第二个线程也在执行，
* 执行到sin==null的判断，那那么线程B获得判断条件也是真，余数继续运行sin=new Singleton(),
* 这样线程A和B都获得了一个对象
* 其实单例也可以通过“克隆”来实现复制，最好不要实现Cloneable接口
* @author dd
*
*/

public class SingletonDemo2 {

    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
    private static SingletonDemo2 instance;  

    private SingletonDemo2(){ //私有化构造器
    }

    //方法同步，调用效率低！
    public static  synchronized SingletonDemo2  getInstance(){
        if(instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }

}

除了饿汉式和懒汉式之外，单例的实现还可以通过双重锁检查机制，静态内部类机制，枚举机制来实现。

双重锁检查机制：解决了懒加载时的效率问题，将同步内容下移到了if内部，不必每次获取对象都要进行同步，只有第一次才需要，创建对象之后就不需要了。
但是，双重锁检查机制由于编译器优化原因和JVM底层内部模型的原因，偶尔会出问题，不建议使用。

public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

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

  private SingletonDemo3() { 

  } 

}

静态内部类机制：
外部类没有static属性，不会像饿汉式那样立即加载对象。而且只有在调用getInstance()才会加载静态内部类。加载类时线程也是安全的，而且instance是static类型，保证了内存中只有一个实例的存在，而且只能被赋值一次。兼备并发高效调用与延迟加载的优势。

public class SingletonDemo4 {

    private static class SingletonClassInstance {
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    private SingletonDemo4(){
    }

    //方法没有同步，调用效率高！
    public static SingletonDemo4  getInstance(){
        return SingletonClassInstance.instance;
    }

}

使用枚举实现单例模式：
优点：
实现简单；枚举本身就是单例模式，由于jvm从根本上提供保障，避免通过反射和反序列化的漏洞。
缺点：
没有延迟加载。

public enum SingletonDemo5 {

    //这个枚举元素，本身就是单例对象！
    INSTANCE;

    //添加自己需要的操作！
    public void singletonOperation(){
    }
}