java的单例模式

java单例模式
 意义：   确保某个类有且只有一个实例。避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且既有一个。
 例如创建一个对象需要消耗资源过多，如要访问IO和数据库资源、网络资源，这事就要考虑使用单例
 特点：   (1)构造方法私有化，一般为private
               (2)通过一个静态方法返回单例对象。
               (3)确保单例类对象只有一个，尤其是在多线程的情况下。
               (4)确保单例类对象在反序列化时，不重新构建对象。
1  懒汉式单列模式
优点：单例只有在使用的时候才会初始化化，在一定程度上节约了资源。
缺点：第一次加载时需要及时的进行初始化，反应稍微慢，最大的问题是每次调用getInstanse
 private static Singleton instance;
      private Singleton()
      {
          
      }  
        public static Singleton getInstance()
          {       
               if(instance==null)
               {
                   instance=new Singleton();
               }
               return instance;
          }
2 饿汉式单列模式
这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化
 private static Singleton instance=new Singleton();
         private Singleton()
         {
            
         }
         public static Singleton getInstance()
         {
             return instance;
         }
3 双重检查（不推荐)
为处理原版非延迟加载方式瓶颈问题，我们需要对 instance 进行第二次检查，目的是避开过多的同步（因为这里的同步只需在第一次创建实例时才同步，一旦创建成功，以后获取实例时就不需要同获取锁了），但在Java中行不通，因为同步块外面的if (instance == null)可能看到已存在，但不完整的实例
 private static Singleton instance;
          private Singleton()
          {
              
          }  
         public static Singleton getInstance()
             {
                 if(instance==null)
               {
                  
                 synchronized (Singleton.class)//高并发状态下上一种很容易产生多个实例，所以我们                                                   需要寻找线程安全的方法，首先最容易就是添加synchronized关键字

                 {              
                   if(instance==null)
                   {
                       instance=new Singleton();
                   }
                 }
               }
                   return instance;
             }
4 内部静态类（安全 推荐）
由于内部静态类只会被加载一次，故该实现方式时线程安全的！
  private Singleton()
        {
            
        }  
          
        public static Singleton getInstance()  
        {  
            return Nested.instance;       
        }  
          
        static class Nested  
        {  
            private static Singleton instance = new Singleton();  
        }     
    这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉不同的是（很细微的差别）饿汉是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比饿汉就显得很合理。
5 枚举 (推荐）
  public enum Singleton
        {
            instance;
            public void operate(){}
        }  //直接调用Singleton.instance;
    这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。