单例模式(Singleton)

单例模式：

    1、简介：

    单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

    2、使用场景：在一个系统中，要求一个类有且仅有一个对象，如果出现多个对象就会出现“不良反应”，可以采用单例模式，具体的场景如下：

    (1).要求生成唯一序列号的环境；

    (2).在整个项目中需要一个共享访问点或共享数据，例如一个web页面上的计数器，可以不用把每次刷新纪录到数据库，使用单例模式保持计数器的值，并确保是线程安全的；

    (3).创建一个对象需要消耗过多的资源，如要访问IO和数据库等资源；

    (4).需要定义大量的静态常量和静态方法(如工具类)的环境，可以采用单例模式(当然，也可以直接声明为static的方式)。

    3.单例模式类图： 

    4.那么单例模式究竟是怎么实现一个类仅仅创建一个类呢，答案是把构造器私有化。

单例模式的写法多达七种，接下来一个一个看。

第一种：饿汉模式

class Singleton {
	private static Singleton instance = new Singleton();

	private Singleton() {
	}

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

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

第二种：（饿汉，变种）：

public class Singleton {

	private Singleton instance = null;
	static {
		instance = new Singleton();
	}

	private Singleton() {
	}

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

这种其实和第一种方式差不多，都是在类初始化即实例化instance。 

第三种：懒汉模式

class Singleton {
	private static Singleton instance;

	private Singleton() {
	}

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

这种写法叫做懒汉模式，只有当你调用getInstance方法，并且instance为null时，才会new这个对象。但是这种写法有缺陷，学过多线程的朋友都知道，这种写法如果在多线程情况下是会出现问题的。当有多个线程同时访问这个方法并且instance为null时，就会创建多个对象了，因此以下有一种改进的方法。加同步方法。

第四种：

class Singleton {
	private static Singleton instance;

	private Singleton() {
	}

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

第五种：Double-check-Lock

public class Singleton {
	private volatile static Singleton instance;

	private Singleton() {
	}

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

Double-check-Lock：这个是第四种方式的升级版，俗称双重检查锁。

第六种：静态内部类

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

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

第七种：枚举

public enum Singleton {
	Instance;
	//添加自己需要的操作
	public void operation() {
		
	}
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。不过，由于1.5中才加入enum特性，用这种方式写的人还是比较少的。

第八种：单例注册表

public class Singleton {
    private final static Map<String, Object> singletonObjects = new ConcurrentHashMap<>(16);

    private Singleton() {
    }
    public static Object getInstance(String className) {
        if (className == null || className.isEmpty()) {
            return null;
        }
        if (singletonObjects.get(className) == null) {
            synchronized (Singleton.class) {
                try {
                    singletonObjects.put(className, Class.forName(className).newInstance());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
        return singletonObjects.get(className);
    }
}