单例模式
一.定义
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）
二.单例模式的八种方式
1.饿汉式（静态常量）
（1）步骤
①构造器私有化
②类的内部创建对象
③向外暴露一个静态的公共方法：getInstance
（2）具体代码
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.本类内部创建对象实例
private final static Singleton singleton = new Singleton();
//3.对外提供获得对象的方法
public static Singleton getInstance(){
return singleton;
}
}
（3）优点
写法比较简单，在类装载的时候就完成实例化，避免了线程同步问题
（4）缺点
在类装载的时候就完成实例化，没有达到懒加载的效果。如果从始至终都没有使用过这个实例，则会造成内存的浪费
这种方式基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就有点早了，因为有可能用不到。
（5）结论
这种单例模式可用，但可能造成内存浪费
2.饿汉式（静态代码块）
（1）代码示例
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.本类内部创建对象实例
private static Singleton singleton;
//3.在静态代码块中实例化
static {
singleton = new Singleton();
}
//4.对外提供获得对象的方法
public static Singleton getInstance(){
return singleton;
}
}
（2）评价
这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例，优缺点和上面是一样的。
（3）结论
这种单例模式可用，但可能造成内存浪费
3.懒汉式（线程不安全的）
（1）具体代码
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.本类内部创建对象实例
private static Singleton singleton;
//3.对外提供获得对象的方法
public static Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
（2）评价
起到了懒加载的效果，但是只能在单线程下使用
（3）结论
在实际开发中，不要使用这种方式
4.懒汉式（线程安全的）
（1）具体代码
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.本类内部创建对象实例
private static Singleton singleton;
//3.对外提供获得对象的方法
public static synchronized Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
（2）优点
解决了线程不安全问题
（3）缺点
效率太低了，每个线程在想获得类的实例的时候，执行getInstance（）方法都要进行同步，而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。
（4）结论
在实际开发中，不推荐使用这种方式
5.懒汉式（双重检查）
（1）具体代码
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.本类内部创建对象实例
private static Singleton singleton;
//3.对外提供获得对象的方法
public static Singleton getInstance(){
if(singleton == null){
synchronized (Singleton.class) {
if(singleton == null) {
//如果没有这个if，就不能用，是错的
singleton = new Singleton();
}
}
}
return singleton;
}
}
（2）评价
Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if(singleton == null)检查，这样就可以保证线程安全了。
不仅实现了懒加载的效果，而且保证了线程安全，效率较高
（3）结论
开发中推荐使用这种单例设计模式
6.静态内部类
（1）具体代码
public class Singleton {
//1.构造方法私有化
private Singleton(){
}
//2.内部类内部创建对象实例
private static class SingletonInstance{
private static final Singleton singleton = new Singleton();
}
//3.对外提供获得对象的方法
public static Singleton getInstance(){
return SingletonInstance.singleton;
}
}
（2）评价
在外部类进行类装载的时候，静态内部类并不会进行装载。这样保证了内存不会浪费。再一个，当内部类进行类装载的时候是线程安全的。
所以线程安全，而且利用了静态内部类的特点实现了懒加载，效率高
（3）结论
在开发中推荐这种方式
7.枚举
（1）具体代码
enum Singleton2{
INSTANCE;
public void sayOK(){
System.out.println("OK");
}
}
public class Main {
public static void main(String[] args) {
Singleton2 instance = Singleton2.INSTANCE;
Singleton2 instance1 = Singleton2.INSTANCE;
System.out.println(instance == instance1);
System.out.println(instance.hashCode());
System.out.println(instance1.hashCode());
/*
true
2129789493
2129789493
*/
}
}
（2）评价
不仅能避免多线程问题，而且还能方式反序列化重新创建新的对象。
（3）结论
开发中推荐使用