java设计模式笔记之单例模式

1.单例模式

单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

3个要点：一是某个类只能有一个实例；而是必须自行创建这个实例；三是必须向整个系统提供这个实例。一般资源管理器、工厂类等都被设计成单例。

2.结构图

结构图很简单，一个Singleton，自己创建和持有自己的一个实例，并保持它唯一。

3.饿汉式单例

public class EagerSingleton {
    private EagerSingleton() { }

    public static EagerSingleton getInstance() {
        return m_instance;
    }

    /** @label Creates */
    private static final EagerSingleton m_instance = new EagerSingleton();
}

饿汉式单例中，类被加载时，单一实例就被创建。

4.懒汉式单例

public class LazySingleton {
	
	private static LazySingleton m_instance = null;
	/*
	 * 私有构造子
	 * 
	 */
	private LazySingleton(){
		
	}
	
	/*
	 * 静态工厂方法，返还此类的唯一实例
	 */
	synchronized public static LazySingleton getInstance(){
		
		if(m_instance == null){
			m_instance = new LazySingleton();
		}
		return m_instance;
	}

}

懒汉式单例在第一次使用时被创建，资源利用率方面比饿汉式单例好。

懒汉式单例在使用时，要考虑多个线程同时访问的同步。

5.双重检测加锁

懒汉式单例，采用线程同步synchronized 确保多个线程首次访问时只有一个线程进入并且创建实例。当实例被创建以后，也是每次都要经过同步才能获得实例，性能不太好。

于是有了双重检测加锁。

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

获得实例时，先判断有没有实例，没有才进入同步块。不过这种方式，经证明在jvm中不成立，有可能会导致程序崩溃，所以不推荐。

崩溃理由在java编译器中，Singleton类的初始化和singleton变量的赋值顺序不可预料。如果一个线程在没有同步化的条件下读取singleton的值，并调用这个对象的方法，可能会发现这个并没有初始化完成。就是singleton有这个对象的引用，但是这个对象没有初始化完成，这个时候程序会崩溃。

6.静态内部类实现的懒汉

综合使用了Java的类级内部类和多线程缺省同步锁的知识，很巧妙地同时实现了延迟加载和线程安全。

1.相应的基础知识

• 　什么是类级内部类？

　　简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。

　　类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。

　　类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。

　　类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载。

• 　多线程缺省同步锁的知识

　　大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：

　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

　　2.访问final字段时

　　3.在创建线程之前创建对象时

　　4.线程可以看见它将要处理的对象时

2.解决方案的思路

　　要想很简单地实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来，不是会浪费一定的空间吗？因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。

　　如果现在有一种方法能够让类装载的时候不去初始化对象，那不就解决问题了？一种可行的方式就是采用类级内部类，在这个类级内部类里面去创建对象实例。这样一来，只要不使用到这个类级内部类，那就不会创建对象实例，从而同时实现延迟加载和线程安全。

public class Singleton {  
      
    private Singleton(){}  
    /** 
     *    类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例 
     *    没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。 
     */  
    private static class SingletonHolder{  
        /** 
         * 静态初始化器，由JVM来保证线程安全 
         */  
        private static Singleton instance = new Singleton();  
    }  
      
    public static Singleton getInstance(){  
        return SingletonHolder.instance;  
    }  
}  

当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

　　这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。

7.枚举实现

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

public enum Singleton {  
    /** 
     * 定义一个枚举的元素，它就代表了Singleton的一个实例。 
     */        
    uniqueInstance;        
    /** 
     * 单例可以有自己的操作 
     */  
    public void singletonOperation(){  
        //功能处理  
    }  
}  

这是从网上看来的实现方法，自己从来没用过，也很少见别人使用。

使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。

8.结语

怎么实现单例，看自己的取舍。饿汉式单例用空间换时间，懒汉式单例和其优化（6），以时间换空间。7是大牛推荐的做法，不过只在java1.5及以后的版本能使用。