java单例－积木系列

一步步知识点归纳吧，把以前似懂非懂，了解表面，知道点不知道面的知识归一下档。

懒汉式单例：
私有化构造函数，阻止外界实例话对象，调用getInstance静态方法，判断是否已经实例化。
为什么是懒汉，因为它是属于延迟加载这个实例的，也就是说不用到的时候，不实例化对象的。

public class Singleton {
private static Singleton instance;
private Singleton (){}

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

}

线程安全问题：当多线程同时调用getInstance()方法，同时判断出instance，进入实例化操作，单利就不复存在。

为了线程安全，那我们对getInstance()方法进行同步化：

public class Singleton {
private static Singleton instance;
private Singleton (){}

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

synchronized修饰保证同一时间只有一个线程可以执行getInstance方法，如此可以保证单例的线程安全。但是同步粒度似乎太大，事实上当实例初始化后我们并不需保证一个个线程排队来取这个实例。

那么就引出来双重检验锁的代码：

public class Singleton {
private static Singleton instance;
private Singleton (){}

public static Singleton getSingleton() {
if (instance == null) {                        //Single Checked
synchronized (this) {
if (instance == null) {                //Double Checked
instance = new Singleton();
}
}
}
return instance ;
}
}

同步快外面和里面check两次，保证在进入同步块的线程不产生新的实例。

当多个线程并发时都判断出实例为null则开始竞争锁，其中一个线程拿到锁去实例化操作，而其他线程需要等待，而实例化好的线程释放所后，后进入的线程如果不判断单例是否已经产生，那么就会又去实例化一个对象，如此就不能实现单例了。
如此双重检验锁开启来完美，而指令重排序会引起问题。我想这也是一个学习重排序的好例子。

instance = new Singleton();

上面这个代码不是一个原子操作，即无法被翻译成一个指令完成。

它是由一下3个指令完成的：

给 instance 分配内存
调用 Singleton 的构造函数来初始化成员变量
将instance对象指向分配的内存空间地址

JVM编译时进行指令重排序可能打乱上面三个指令的执行顺序，也就是说可能先直行来1，3然后执行2。那么有这么一种情况当执行好1和3，instance不为null，新进入的线程在判断第一个null时就会直接返回一个没有执行2步骤的实例，如此就有不符合期望了。这的确是个经典的场景。

额外阅读

如果我们在实例初始化后，将第三步，分开写，似乎可以解决这个问题，代码如下：

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

volatile关键字事实上是对编译时的重排序进行了屏障。具体各家说法可以阅读下面的文章：
扩展阅读

由上可以感受到，在加载时就初始化好实例，会有很多需要考虑的东西，那么如果在编译阶段就实例化好，如此就可以避免并发带来的问题。

那就是所谓的饿汉式单例：

public class Singleton{

//类加载时就初始化
private static final Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){
return instance;
}
}

当然这样做自然有自己的弊端，就是这个单例在没有被使用到的时候就已经需要实例化出来，如此就会占用无谓占用内存，如果这个实例初始化复杂占用资源，而实际未必会使用就比较尴尬了。

或者说，这种方式实例化将无法实现依赖外部参数实例化的场景。

还有一种推荐写法：

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

还有一种大师推荐的写法，有没有很高大上：

public enum EasySingleton{

INSTANCE;
}

我们来看看如何破坏单例：

1，序列化与反序列化
当然我们前面写的代码不需要序列化和反序列化，就没有这个问题了，只是说送这个方面我们考虑如何破坏它，参考如下例子：

public class Singleton implements Serializable{
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;
}
}
public class SerializableDemo1 {
//为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
//Exception直接抛出
public static void main(String[] args) throws IOException, ClassNotFoundException {
//Write Obj to file
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
oos.writeObject(Singleton.getSingleton());
//Read Obj from file
File file = new File("tempFile");
ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
Singleton newInstance = (Singleton) ois.readObject();
//判断是否是同一个对象
System.out.println(newInstance == Singleton.getSingleton());
}
}
//false

2，反射

public class Singleton {
public static final Singleton INSTANCE = new Singleton();
private Singleton() {
}
public Singleton getInstance() {
return INSTANCE;
}
public static void main(String[] args) throws Exception {
// 反射机制破坏单例模式
Class clazz = Singleton.class;
Constructor c = clazz.getDeclaredConstructor();
// 反射机制使得private方法可以被访问！！！
c.setAccessible(true);
// 判断反射生成的对象与单例对象是否相等
System.out.println(Singleton.INSTANCE == c.newInstance());
}
}

破坏单例的原理就是，不走构造函数即可产生实例的方式，因为我们只关闭了构造函数。

至此，对java单例有一个比较全面的认识，牵涉到大量知识点，需要继续挖掘。

－－－－－－－－－－－－－－－－－－－－－－－20170227补充begin－－－－－－－－－－－－－－－－－

3，原型模式

看到原型模式的时候，发现clone方法产生对象也是可以绕过构造函数私有化的。

－－－－－－－－－－－－－－－－－－－－－－－20170227补充end－－－－－－－－－－－－－－－－－

－－－－－－－－－－－－－－－－－－－－－－－ 20170125补充begin－－－－－－－－－－－－－－－－－－－

刚好读spring ioc源码的时候看到这个类：DefaultSingletonBeanRegistry

看到有这么个模式可以学习下：Registry of Singleton 模式

public class Singleton {
// 注册表，用于注册子类别物件
private static Map registry = new HashMap();
private static Singleton instance;

public static void register(
String name, Singleton singleton) {
registry.put(name, singleton);
}

public static Singleton getInstance() {
if (instance == null) {
// getEnv表示取得环境变数
String style = getEnv("style");
instance = lookup(style);
}

return instance;
}

protected static Singleton lookup(String name) {
return (Singleton) registry.get(name);
}
}

说白了就是创建个容器管理各种不同的单例，便于统一管理，集中单例的代码。

public class SingletonRegistry {
private static Map<String, Object> registry =
new HashMap<String, Object>();

private SingletonRegistry() {}

public static Object getInstance(String classname) {
Object singleton = registry.get(classname);

if(singleton != null) {
return singleton;
}
try {
singleton = Class.forName(classname).newInstance();
}
catch(Exception e) {
throw new RuntimeException(e);
}

registry.put(classname, singleton);

return singleton;
}
}

－－－－－－－－－－－－－－－－－－－－－－－ 20170125补充end－－－－－－－－－－－－－－－－－－－

让我们继续前行

----------------------------------------------------------------------

努力不一定成功，但不努力肯定不会成功。