单例模式

题目

描述
单例 是最为最常见的设计模式之一。对于任何时刻，如果某个类只存在且最多存在一个具体的实例，那么我们称这种设计模式为单例。例如，对于 class Mouse (不是动物的mouse哦)，我们应将其设计为 singleton 模式。

你的任务是设计一个 getInstance 方法，对于给定的类，每次调用 getInstance 时，都可得到同一个实例。

样例
在 Java 中:

A a = A.getInstance();
A b = A.getInstance();
a 应等于 b.

挑战
如果并发的调用 getInstance，你的程序也可以正确的执行么？

解答

public class Solution {
    private static Solution solution = null;

    /**
     * @return: The same instance of this class every time
     */
    public static Solution getInstance() {
        // write your code here
        if (solution == null) {
            return new Solution();
        }
        return solution;
    }
}

附所有单例的实现方式：

public class DanLi {

}

/**
 * 简单模式(懒汉)，多线程场景下无法控制只创建一个实例
 *
 */
class SingleDemo1 {

    private static SingleDemo1 singleDemo1 = null;

    private SingleDemo1() {
    }

    public static SingleDemo1 getInsatance() {
        if (singleDemo1 == null) {
            singleDemo1 = new SingleDemo1();
        }
        return singleDemo1;
    }
}

/**
 * 同步的模式(懒汉)，可以保证多线程场景下只创建一个，但是效率太低
 *
 */
class SingleDemo2 {
    private static SingleDemo2 singleDemo2 = null;

    private SingleDemo2() {
    }

    public static synchronized SingleDemo2 getInsatance() {
        if (singleDemo2 == null) {
            singleDemo2 = new SingleDemo2();

        }
        return singleDemo2;
    }

}

/**
 * 简单饿汉模型，可以保证多线程环境下单例，instance在类装载时就实例化，不是懒加载模式
 *
 */
class SingleDemo3 {
    private static SingleDemo3 singleDemo3 = new SingleDemo3();

    private SingleDemo3() {
    }

    public static SingleDemo3 getInsatance() {
        return singleDemo3;
    }
}

/**
 *这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不同的是（很细微的差别）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。
 */
class SingleDemo4 {
    private static class SingletonHolder {
        private static final SingleDemo4 instance = new SingleDemo4();
    }

    private SingleDemo4() {
    }

    public static SingleDemo4 getInsatance() {
        return SingletonHolder.instance;
    }
}

enum SingletonDemo6 {
                     instance;
    public void whateverMethod() {
    }
}

/**
 * 双重校验锁
 *
 */
class SingleDemo7 {
    private volatile static SingleDemo7 singletonDemo7;

    private SingleDemo7() {
    }

    public static SingleDemo7 getSingletonDemo7() {
        if (singletonDemo7 == null) {
            synchronized (SingleDemo7.class) {
                if (singletonDemo7 == null) {
                    singletonDemo7 = new SingleDemo7();
                }
            }
        }
        return singletonDemo7;
    }
}