设计模式—单例模式

定义：确保某一个类只有一个实例， 而且自行实例化并向整个系统提供这个实例（Ensure a class has only one instance, and provide a global point of access to it.）。

实现方式：饿汉模式、懒汉模式、枚举模式、类加载方式、双重检查加锁

1.饿汉模式

public class Singleton{    private static final Singleton singleton = new Singleton();    //通过定义一个私有访问权限的构造函数， 避免被其他类new出来一个对象，限制产生多个对象    private Singleton(){}    //通过该方法获得实例对象    public static Singleton getSingleton(){            return singleton;    }    //类中其他方法，尽量是static    public static void doSomething(){}}

饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变
即立即创建，线程安全

2.懒汉模式

public class Singleton {       private static Singleton singleton;       //限制产生多个对象     private Singleton (){}     //通过该方法获得实例对象，通过加锁来控制线程安全     public static synchronized Singleton getSingleton() {       if (singleton == null) {            singleton = new Singleton();          }          return singleton;       }        //类中其他方法，尽量是static    public static void doSomething(){} }  

懒汉式优点是延时加载、 是在需要的时候才创建对象，通过加锁的方式来控制线程安全，否则会出现线程不安全的情况，但同步情况下效率低。例如A，B两个线程同时请求资源，如果A的请求还没有完成B的请求就来了，就会出现很多种情况，线程是不安全的。
即延迟加载，线程安全

3.双重检查加锁

       public class Singleton {            private static volatile Singleton singleton;           //限制产生多个对象          private Singleton (){}             public static Singleton getSingleton() {            //先检查对象实例是否存在               if (singleton == null) {                   //同步块，线程安全的创建实例                      synchronized (Singleton.class) {                     //再次检查实例是否存在，如果不存在才真正的创建实例                 if (singleton == null) {                       singleton = new Singleton();                   }                }            }           return singleton;           }            //类中其他方法，尽量是static          public static void doSomething(){}     }  

延迟加载：在需要的时候才创建对象
线程安全
同步情况下效率高：先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块后，再次检查实例是否存在，如果不存在，就在同步的 情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。

volatile类型变量可以保证写入对于读取的可见性，保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。同时禁止进行指令重排序，JVM不会将volatile变量上的操作与其他内存操作一起重新排序，volatile变量不会被缓存在寄存器，因此保证了检测instance状态时总是检测到instance的最新状态。

4.静态内部类加载方式

 public class Singleton implements java.io.Serializable ,Cloneable {            //静态内部类          private static class SingletonHolder {                 private static final Singleton INSTANCE = new Singleton();            }            //限制产生多个对象          private Singleton (){}          //公开的唯一访问点          public static final Singleton getInstance() {               return SingletonHolder.INSTANCE;            }            //自定义反序列化返回的对象          private Object readResolve() throws ObjectStreamException{                return getInstance();          }          private Object clone() throws CloneNotSupportedException{                return getInstance();         }  }  

延迟加载
同步情况下效率高
实现麻烦
自由序列化：实现java.io.Serializable ,Cloneable接口后防止反序列化
线程安全：由于内部类不会在类的外部被使用，所以只有在调用getInstance()方法时才会被加载。同时依赖JVM的ClassLoader类加载机制保证了不会出现同步问题。

5.枚举模式

   public enum Singleton {           INSTANCE;         public void doSomething() {          System.out.println("Something");        }          public static void main(String[] args) {            Singleton.INSTANCE.doSomething();        }    }  

立即加载
实现简单
自由序列化：因为每一个枚举类型和枚举变量在JVM中都是唯一的，即Java在序列化和反序列化枚举时做了特殊的规定，不存在实现序列化接口后调用readObject会破坏单例的问题。
线程安全：由于枚举类的会在编译期编译为继承自java.lang.Enum的类，其构造函数为私有，不能再创建枚举对象，枚举对象的声明和初始化都是在static块中，保证了线程的安全性。但是不能实现延迟加载，保证单例