转自：http://blog.csdn.net/willamlan/article/details/48596237

设计模式之-------单例模式

---

在现有的23种设计模式中，可以说单例模式是所有设计模式中最简单的一种。

单例模式就是说系统中对于某类的只能有一个对象，不可能再出来第二个。

通过单例模式，自行实例化并向这个系统提供这个单一实例的访问方法。

单例模式也是23中设计模式中在面试时少数几个会要求写代码的模式之一。

主要考察的是多线程下单例模式的线程安全性问题。

单例模式实例一(不使用同步锁)

    public class Singleton {  
        private static Singleton sin=new Singleton();    ///直接初始化一个实例对象  
        private Singleton(){    ///private类型的构造函数，保证其他类对象不能直接new一个该对象的实例  
        }  
        public static Singleton getSin(){    ///该类唯一的一个public方法      
            return sin;  
        }  
    }  

上述代码中的一个缺点是该类加载的时候就会直接new 一个静态对象出来，当系统中这样的类较多时，会使得启动速度变慢 。现在流行的设计都是讲“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象。所以上述这种只适合在小系统。

单例模式实例二(使用同步方法)

public class Singleton {    
     private static Singleton instance;    
     private Singleton (){  
           
     }     
     public static synchronized Singleton getInstance(){    //对获取实例的方法进行同步  
       if (instance == null)       
         instance = new Singleton();   
       return instance;  
     }  
 } 

　　上述代码中的一次锁住了一个方法， 这个粒度有点大 ，改进就是只锁住其中的new语句就OK。就是所谓的“双重锁”机制。
单例模式实例三(使用双重同步锁)

    public class Singleton {    
         private static Singleton instance;    
         private Singleton (){  
         }     
         public static Singleton getInstance(){    //对获取实例的方法进行同步  
           if (instance == null){  
               synchronized(Singleton.class){  
                   if (instance == null)  
                       instance = new Singleton();   
               }  
           }  
           return instance;  
         }  
     }  

附注：根据此单一实例产生的时机不同（当然，都是指第一次，也是唯一一次产生此单一实例时），可以将其分为懒汉式、饿汉式和登记式。
一、懒汉式：
其特点是延迟加载，即当需要用到此单一实例的时候，才去初始化此单一实例。如上面的单例模式实例二。

二、饿汉式：
饿汉式的特点是应用中尚未需要用到此单一实例的时候即先实例化。如上面的单例模式实例一。

三、登记式单例模式：
登记式单例模式，一般是通过一个专门的类对各单例模式的此单一实例进行管理和维护。通过Map方式可以方便的实现此中目的。常见的代码如下：

    import java.util.HashMap;  
    import java.util.Map;  
      
    public class SingleTonManager {  
      
        private static Map singleTonMap = new HashMap();  
      
        public static void main(String[] args) {  
            // 获取A类的单例  
            A a = (A) getInstance(A.class.getName());  
            // 获取B类的单例  
            B b = (B) getInstance(B.class.getName());  
        }  
      
        // 根据类型获取单例  
        public static Object getInstance(String className) {  
            // 判断singleTonMap中是否有此单例，有则取得后返回，无则添加单例后返回  
            if (!singleTonMap.containsKey(className)) {  
                try {  
                    singleTonMap.put(className, Class.forName(className).newInstance());  
                } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
            return singleTonMap.get(className);  
        }  
    }  
      
    class A {  
      
    }  
    class B {  
      
    }  

四、改进型懒汉式（直接满足线程安全）——通过静态内部类实现
在如上的懒汉单例模式中，对于多线程环境中。可以通过常见的如synchronized等方式实现线程安全，同时，可以通过Java静态内部类的方式实现进一步改进。
常见代码如下：

    public class SingleTon {  
      
        // 利用静态内部类特性实现外部类的单例  
        private static class SingleTonBuilder {  
            private static SingleTon singleTon = new SingleTon();  
        }  
      
        // 私有化构造函数  
        private SingleTon() {  
      
        }  
      
        public static SingleTon getInstance() {  
            return SingleTonBuilder.singleTon;  
        }  
      
        public static void main(String[] args) {  
            SingleTon instance = getInstance();  
        }  
    }  

其主要原理为：Java中静态内部类可以访问其外部类的成员属性和方法，同时，静态内部类只有当被调用的时候才开始首次被加载，利用此特性，可以实现懒汉式，在静态内部类中静态初始化外部类的单一实例即可。