第三章《Java设计模式之单例模式》设计模式 单例模式

单例模式

简介

保证一个类仅有一个实例，并提供一个访问他的全局访问点。

应用场景

在某些情况下，我们可能只需要某个类智能创建一个对象，即不让用该类实例化多于两个的实例。比如打印机。所有的打印的机子都通过一台打印机。这样避免了，同一个文件有两台打印机打印的情况。

角色

• 单例类

UML类图

未完待续。。。

例子

关于单例模式有很多种，下面来一一列举。

1. 懒汉式单例模式(线程不安全)

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

懒汉式顾名思义，就是用到的时候再去创建该实例。但遇到高并发情况下，有可能产生线程不安全的情况。

1. 懒汉式单例模式(线程安全)

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

这种比1中加了锁，能够很好处理线程，但加锁影响了性能。

1. 饿汉式单例模式（线程安全，但消耗内存）

public class Singleton{
    private Singleton(){}
    private static Singleton = new Singleton;
    public static Singleton  getSingleton (){
        return Singleton  
    }
}

虽然能避免了线程安全和加锁。但初始化就加载，比较消耗内存。但现在一般不考虑硬件问题。

1. 双重检查加锁 综合。既可以不用类加载初始化，又能保持线程安全

public class Singleton {
    private volatile static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance == null){
            //同步块，线程安全的创建实例
            synchronized (Singleton.class) {
                //再次检查实例是否存在，如果不存在才真正的创建实例
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

用双重if判断，复杂，容易出错。也有加锁，还是影响性能。

1. 静态内部类方法

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

这种最好的，既可以不用类加载初始化，又能保持线程安全。额外知识：
大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：
　　1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时
　　2.访问final字段时
　　3.在创建线程之前创建对象时
　　4.线程可以看见它将要处理的对象时
这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。

1. 单例和枚举

http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html最优解