1. 什么是单例模式？
确保一个类只有一个实例，并提供一个全局访问点
单例模式见名知意， 就是只有一个实例。在整个系统应用中不管获取多少次，拿到的都是同一个对象， 这就是单例模式。
2. 单例模式用来干什么，什么时候使用？
我们知道了单例模式的意思， 那么为什么要用这个单例模式呢？
答案很简单，在需要重复创建和销毁对象的时候使用单例模式，可以节省系统资源，比如工具类、DAO等这种在多个地方使用却只需要一个实例就可以完成操作的类，我们就可以把它设计为单例模式。
3. 怎么实现单例模式？
-
饿汉式
饿汉式，启动时就初始化完毕，不存在线程安全问题，实例不使用会消耗资源
package com.single.hungry;
public class Hungry {
private final static Hungry hunger = new Hungry();
private Hungry() {
}
public static Hungry getInstance() {
return hunger;
}
}
-
懒汉式
第一版：使用时初始化，但是无法保证线程安全，有可能两个线程同时进入到 if (null == lazyOne)判断里面，然后初始化两次。
package com.single.lazy;
public class LazyOne {
private static LazyOne lazyOne;
private LazyOne() {
System.out.println("init");
}
public static LazyOne getInstance() throws InterruptedException {
if (null == lazyOne) {
Thread.sleep(1000);
lazyOne = new LazyOne();
}
return lazyOne;
}
}
第二版：使用synchronized关键字，线程安全，每次访问都会加锁，效率不高
package com.single.lazy;
public class LazyTwo {
private static LazyTwo lazyTwo;
private LazyTwo() {
System.err.println("init");
}
public static synchronized LazyTwo getInstance() throws InterruptedException {
if (null == lazyTwo) {
lazyTwo = new LazyTwo();
}
return lazyTwo;
}
}
第三版：双重锁，线程安全
package com.single.lazy;
public class LazyFour {
private LazyFour(){
System.err.println("init");
}
//一个线程中对该变量的修改对其他线程可见
public volatile static LazyFour lazyFour = null;
public static LazyFour getInstance() {
if (lazyFour == null) {
synchronized (LazyFour.class) {
if (lazyFour == null) {
lazyFour = new LazyFour();
}
}
}
return lazyFour;
}
}
第四版：静态内部类实现，当调用LazyThree时，才会去初始化LazyHolder.LazyThree .lazy实例。
package com.single.lazy;
public class LazyThree {
private LazyThree() {
System.err.println("init");
}
public static final LazyThree getInstance() {
return LazyHolder.lazy;
}
public static class LazyHolder {
private static final LazyThree lazy = new LazyThree();
}
}
最后还有什么注册式单例（Spring中使用）、枚举单例就不贴代码了。
