新手Java 单例模式详解

Java 单例模式

个人Java学习笔记，如有错误，请指正。

单例模式

单例模式核心就是这个类只有一个对象，同过静态的方法去获取这个对象进行访问，不能去实例化，所以构造方法都是私有的。
1.饿汉式
饿汉式没什么好说的，上来啥也不管就创建了对象，线程安全，但是对象随着类加载的时候就创建了，因此内存资源的浪费。

public class Single {
    //饿汉式
    private  Single(){};
    private static Single single = new Single();

    public static Single getSingle() {
        return single;
}
}

2.懒汉式
懒汉式，顾名思义突出一个懒字，什么时候用什么时候去创建对象。

//懒汉式

public class Single { 
	private  Single(){};
    private static Single single;
    public static Single getSingle() {
        if(single == null){
            single = new Single();

        }
        return single;
    }
    }

关键问题在于这个判空语句，当线程A走完判空语句，线程B抢到了CPU，接着去创建对象，B结束后A又抢到，继续又new了一个对象，这样单例就没意义了，所以想了想，加个锁吧。

public class Single { 
	private  Single(){};
    private static Single single;
    public static synchronized Single getSingle() {
        if(single == null){
            single = new Single();

        }
        return single;
    }
    }

可是这样又出问题了，当用户想拿这个对象时，每次都要走一遍加锁的方法，就算single不为空的时候不需要new对象的时候，都要走用锁的代码，大家都知道锁是很占用资源的，行，那就把判空语句拿出来。

public class Single { 
 	private  Single(){};
    private static Single single;
    public static  Single getSingle() {
        if(single == null) {
            synchronized (Single.class) {
                single = new Single();
                }
        }
        return single;
    }
    }

这样又出新问题了。线程A刚走完判空语句，线程B又抢到CPU了，又是new了两次对象，彷佛又回到了起点，这时大家应该想到了，再在锁里加一个判空语句不就行了，那就是接下来的双检锁。

3.双重检验懒汉式

public class Single { 
 	private  Single(){};
    private static volatile Single single;
    public static  Single getSingle() {
        if(single == null) {
            synchronized (Single.class) {
             if(single == null) {
                single = new Single();
                }
          }
        }
        return single;
    }
    }

这样就可以了，既解决了线程问题，又尽力的去保证不造成资源的浪费。
4.静态内部类

public class Single { 
    //静态内部类
    private  Single(){};

  private static class neibu{
       private static Single single = new Single();
   }

   public static Single getSingle() {
        return neibu.single;
    }
 }

静态内部类实现了懒加载，懒加载就是内部类只有在本类实例化的时候才会加载，这样就只会进行一次，所有节约了资源。
5.枚举
枚举类型本身的特性就让序列化和反序列化以及反射的时候不会出现问题，如果用到了序列化和反序列化时，强烈建议用枚举类型实现单例模式，不然会出现大问题。

public class Single { 
//枚举
    private  Single(){};
    enum single1{
        INSTANCE;
        Single single;
        single1(){
            single = new Single();
        }
    }
    public static Single getSingle() {
        return single1.INSTANCE.single;
    }
    }