Java单例模式

   Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。

   单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。

  

要保证在一个JVM中只能存在一个实例，要考虑到如下的情况：

• Java能够使用那些方式构建对象
• Java在创建对象时多线程并发情况下是否仍然只能创建一个实例

Java创建对象的方法：

• new 最常用的，直接使用构造器创建。 每new一次都会产生新的实例。所以单例中应该只new一次，当再想用对象时都返回该对象的值
• Class.newInstance() 该方法会调用public 的无参构造器。
  为了防止这个方式创建，只要把构造器设置为private的就可以了。这是如果再用这个方法创建会报错.同时私有构造器也可以解决四处new的问题。
• 反射
  Constructor ctt = c.getDeclaredConstructor();
  ctt.setAccessible(true);
  T t1 = ctt.newInstance();
  这样私有构造器也不行了。解决的办法是使用抽象类，这样就会抛出异常了，不能创建了。或者在构造器中加入判断如果是第二次构建就抛出异常。
• clone
  这个主要由clone()方法的具体行为决定的。如果没有实现Cloneable接口是不用管这个问题的。
• 反序列化
  反序列化的时候也会打破单例，解决的方式是写一个readResolve。这个方法的规则是在反序列化的时候勇气返回值来代替反序列化的返回值
  还有一个更简单的办法是不要实现Serializable接口，这样序列化的时候就会报错了

Java单例模式的7种实现

第一种，线程不安全（懒汉模式）

 1 public class Singleton1 {
 2     private static Singleton1 instance;
 3     private Singleton1(){}
 4     public static Singleton1 getInstance(){
 5         if(instance == null){
 6             instance = new Singleton1(); 7  } 8 return instance; 9  } 10 }

lazy loading，但是多线程不安全。不推荐。

第二种，线程安全（懒汉模式）

 1 public class Singleton2 {
 2     private static Singleton2 instance;
 3     private Singleton2(){}
 4     public static synchronized Singleton2 getInstance(){
 5         if(instance == null){
 6             instance = new Singleton2(); 7  } 8 return instance; 9  } 10 }

lazy loading，线程安全，但是效率极其低下，同步锁锁的是对象，每次取对象都有加锁，因此不推荐，性能很低。

第三种，线程安全（饿汉模式）

1 public class Singleton3 {
2     private static Singleton3 instance = new Singleton3();
3     private Singleton3(){}
4     public static synchronized Singleton3 getInstance(){
5         return instance;
6  } 7 }

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，这时候初始化instance显然没有达到lazy loading的效果。不推荐。

第四种，线程安全（饿汉模式）

 1 public class Singleton4 {
 2     private static Singleton4 instance ;
 3     static {
 4         instance = new Singleton4();
 5     }
 6     private Singleton4(){}
 7     public static synchronized Singleton4 getInstance(){
 8         return instance;
 9     }
10 }

等同于第三种

第五种，线程安全（静态内部类）

1 public class Singleton5 {
2     private Singleton5(){}
3     public static synchronized Singleton5 getInstance(){
4         return SingletonHolder.instance;
5     }
6     private static class SingletonHolder{
7         private static Singleton5 instance = new Singleton5();
8     }
9 }

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。

第六种，线程安全（枚举类）

1 public enum Singleton6 {
2     INSTANCE;
3     public void whateverMethod(){}
4 }

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，推荐！

第七种，线程安全（双重校验模式）

 1 public class Singleton7 {
 2     private static Singleton7 instance;
 3     private Singleton7(){}
 4     public static synchronized Singleton7 getInstance(){
 5         if(instance == null){
 6             synchronized (Singleton7.class){
 7                 if(instance ==null){
 8                     instance = new Singleton7();
 9                 }
10             }
11         }
12         return instance;
13     }
14 
15 }

最常用的一种。

总结

有两个问题需要注意：

     1、如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类  装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。

     2、如果 Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。