Java单例设计模式精要及Android源码实例

最近正在找工作，好多家公司在面试中会问单例设计模式，自己以前也用过，也能说上个大概来。
以下是没有回答上来的问题：
1.在懒汉式单例模式中同步(synchronized) 写在方法中和写在判断语句中有什么区别？
2.还问了个用静态内部类写过单例没、用的啥机制？
瞬间晕了。。。痛定思痛，回来在网上一查果然有大文章。

接下来简单的介绍下单例模式的特点：

　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

Android中的实例：

　　系统服务都是通过容器的单例模式实现方式，单例形式存在，减少资源消耗。如LayoutInflater Service,将这些服务以键值对的形式存储在一个HasMap容器中，用户使用时，只需要通过key来获取到对应的ServiceFetcher对象,在createService函数创建服务对象，将对象缓存到一个列表中，下次可以直接获取服务，实现单例。

这里主要介绍两种：

　懒汉式单例、饿汉式单例
　

一、懒汉式单例

    //懒汉式单例类.在第一次调用的时候实例化自己   
    public class Singleton {  
        private Singleton() {}  
        private static Singleton single=null;  
        //静态工厂方法   
        public static Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
        }  
    }  

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（注意：事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全。

1、在getInstance方法上加同步

    public static synchronized Singleton getInstance() {  
             if (single == null) {    
                 single = new Singleton();  
             }    
            return single;  
    }  

注释：在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的

2、双重检查锁定

    public static Singleton getInstance() {  
            if (singleton == null) {    
                synchronized (Singleton.class) {    
                   if (singleton == null) {    
                      singleton = new Singleton();   
                   }    
                }    
            }    
            return singleton;   
        }  

注释；在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

3、静态内部类

    public class Singleton {    
        private static class LazyHolder {    
           private static final Singleton INSTANCE = new Singleton();    
        }    
        private Singleton (){}    
        public static final Singleton getInstance() {    
           return LazyHolder.INSTANCE;    
        }    
    }    

注释：利用了**classloader**的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。（对于ClassLoader加载机制可以自行在网上查找，是Java基础挺重要）

注意：这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

二、饿汉式单例

    //饿汉式单例类.在类初始化时，已经自行实例化   
    public class Singleton1 {  
        private Singleton1() {}  
        private static final Singleton1 single = new Singleton1();  
        //静态工厂方法   
        public static Singleton1 getInstance() {  
            return single;  
        }  
    }  

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