单例模式

最近在看《剑指offer》，根据《剑指offer》的讲解，结合《effectiveJava》简单学习了一下单例模式。第一篇文章，算是一个学习笔记，以后回来翻阅。

Singleton指仅仅被实例化一次的类。Singleton通常被用来代表那些本质上唯一的系统组件，比如窗口管理器或者文件系统。

一、懒汉式

在第一次调用时实例化自己

1、由于要求只能生成一个实例，则必须把构造函数设为私有函数，以禁止他人创建实例。

2、则需要定义一个静态的实例，在需要的时候进行创建。

public class Singleton {
   private Singleton(){};
   private static Singleton instance=null;
    //静态工厂方法
   public static Singleton getInstance() {
       if (instance==null)
            instance=new Singleton();
       return instance;
   }
}

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

如果两个线程同时运行到判断"instance==null"的if语句，并且instance的确没有创建时，那么两个线程都会创建一个实例，则该类就不能满足单例模式的要求。

二、保证线程安全，但效率不高

为了保证在多线程环境下，我们依然只能得到类型的一个实例，需要加上一个同步锁，将上面程序稍作修改得到：

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

同样假设有两个线程同时想创建一个实例。由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁时，第二个线程只能等待。当第一个线程发现实例还没有创建时，它创建出一个实例。接下来第一个线程释放同步锁，此时发现第二个线程可以加上同步锁，并运行接下来的代码。由于此时实例已经被第一个线程创建出来，第二个线程就不会重复创建实例了，这样就保证了我们再多线程环境中也只能得到一个实例。

但是，我们每次通过属性getInstance得到Singleton 实例时，都会试图加上一个同步锁，加锁是非常耗时的工作，没必要时应当尽量避免。

三、双重检查锁定

我们只需要在实例还没有创建之前需要加锁操作，以保证只有一个线程创建出实例。而当实例已经创建之后，我们已经不需要再做加锁操作。

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

以上算法中，只有当instance为null，没有创建时，需要加锁操作。当instance已经创建出来之后，则无需加锁。通过加锁机制来确保多线程环境下只创建一个实例，并且用两个if判断来提高效率。是一种可行的方法。

四、静态内部类

//静态内部类
public class Singleton {
    private Singleton(){}
    private static class SingletonHolder{
        private static final Singleton instance=new Singleton();
    } 
    public static final Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

1、使用静态内部类既实现了线程安全

由于 SingletonHolder是私有的，除了 getInstance() 之外没有办法访问它，因此它只有在getInstance()被调用时才会真正创建；

2、避免了同步带来的性能影响。

读取实例的时候不会进行同步。

五、饿汉式单例

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，天生是线程安全的。不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

//饿汉式
public class Singleton {
    private Singleton(){}
    private static final Singleton instance=new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

六、包含单个元素的枚举类型实现单例（最佳方法）

从Java1.5发行版本起，实现Singleton还可以使用只包含一个元素的枚举类型：

enum Singleton{
    instance;
}

优点：更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。