实现Singleton模式，需要要把构造器保持为私有的，并导出公有的静态成员，以便允许客户端能够访问该类的唯一实例。

1. 饿汉式(Eager mode)：单例对象是个 final域，在类加载期间，就实例化一个对象交给自己的引用instance，如：

// Singleton with Eager mode public class SingletonA {     //实例化一个对象交给自己的引用     private static final instance = new SingletonA();     //私有化构造器     private SingletonA(){}     //返回单例对象     public static SingletonA getInstance()     {         return instance;     } } 

2. 懒汉式(Lazy mode)公有的成员是个静态工厂方法，在调用取得实例方法的时候才会实例化对象

• 懒汉第1式：

//Singleton with Lazy mode public class SingletonB {     private static instance;     private SingletonB(){}     public static SingletonB getInstance()     {         if(instance == null)             instance = new SingletonB();         return instance;     } } 

如果线程1进入了if语句，但还未实例化instance，此时，线程2访问到getInstance的if判断，因为instance还未实例化，所以也进入if内部；于是线程1和线程2，最后创建了两个实例。

• 懒汉第2式：同步锁

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

可以有效防止多线程在执行getInstance方法得到2个对象，但是：

只有在instance为null时，才必须要求同步。一旦singleton不为null，系统依旧花费同步锁开销

• 懒汉第3式：

public static SingletonB getInstance() {          if(instance == null)//1         synchronized(SingletonB.class)//2         {             instance = new SingletonB();//3         }         return instance; } 

这种写法减少了锁开销，但是依旧可能创建了2个对象。

1. 线程1执行到1挂起，线程1认为singleton为null
2. 线程2执行到1挂起，线程2认为singleton为null
3. 线程1被唤醒执行synchronized块代码，走完创建了一个对象
4. 线程2被唤醒执行synchronized块代码，走完创建了另一个对象

• 懒汉第4式：双重锁定检查（DCL）

public static SingletonB getInstance() {          if(instance == null)//1         synchronized(SingletonB.class)//2         {             if(instance == null)             {                 instance = new SingletonB();//3             }         }         return instance; } 

看是没有问题，但在instance = new SingletonB()这句中，却暗藏杀机，因为jvm在执行这句代码时，实际分为三步：开辟内存空间，赋值给引用，初始化数据。这是需要消耗时间。

• 懒汉最终式：volatile

volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。

//Singleton with Lazy mode public class SingletonB {     private static volatile instance;     private SingletonB(){}     public static SingletonB getInstance()     {         if(instance == null)//1         synchronized(SingletonB.class)//2         {             if(instance == null)             {                 instance = new SingletonB();//3             }         }         return instance;     } } 

volatile变量具有synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile变量的最新值

3. Lazy initialization holder class模式

根据JLS(Java Language Specification)中的规定，一个类在一个ClassLoader中只会被初始化一次，这点是JVM本身保证的

public class SingletonC {     private static instance;     //私有化构造器     private SingletonC(){}     //返回单例对象     public static SingletonC getInstance()     {         return SingletonHolder.INSTANCE;     }     private static class SingletonHolder     {         //单例对象实例         static final SingletonC INSTANCE = new SingletonC();          }   } 

• 这种写法仍然使用JVM本身机制保证线程安全问题
• 由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的
• 同时读取实例的时候不会进行同步，没有性能缺陷
• 也不依赖JDK版本

4. 从其他途径屏蔽构造单例对象的方法

• 直接new单例对象

一般加入一个private或者protected的构造函数

• 通过反射构造单例对象

需要在ReflectPermission("suppressAccessChecks") 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。 一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现

• 通过序列化构造单例对象

单例对象有必要实现Serializable接口，则应当同时实现readResolve()方法，以保证反序列化的时候得到原来的对象

public class Singleton implements Serializable  {     private static class SingletonHolder     {         static final Singleton INSTANCE = new Singleton();          }          public static Singleton getInstance()     {              return SingletonHolder.INSTANCE;      }     //private的构造函数用于避免外界直接使用new来实例化对象       private Singleton() {          }          //readResolve方法应对单例对象被序列化        private Object readResolve() {              return getInstance();          }      }     

5. 单例与枚举

按照《Effective Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。

public enum SingletonEnum {     INSTANCE;     private String field;     public String getField()     {         return field;     }     public void setField(String field)     {         this.field = field;     }     @Override     public String toString()     {         return "SingletonEnum{" +             "field='" + field + '\'' +             '}';     } } 

• 自由序列化
• 保证只有一个实例(使用反射机制也无法多次实例化一个枚举量)
• 线程安全

Singleton Mode总结

1. 优点

• 在内存中只有一个对象，节省内存空间
• 避免频繁的创建销毁对象，可以提高性能
• 避免对共享资源的多重占用
• 可以全局访问

2. 适用场景

• 需要频繁实例化然后销毁的对象
• 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
• 有状态的工具类对象。
• 频繁访问数据库或文件的对象。