单例模式.

什么是单例模式呢？单例模式是一种非常常见的设计模式。在目前的学习中有非常经典的两种设计模式——饿汉模式，懒汉模式。

1.饿汉模式

class singalton{
    private singalton(){}
    private static singalton instance=new singalton();
    public  static singalton getsingalton(){
        return instance;
    }
}
public class singal {
    public static void main(String[] args) {
        //singalton s1=new singalton();由于类的构造方法是私有的，main类不能直接访问到，所以不能直接new.作为内部类的时候可以直接new.
        singalton s= singalton.getsingalton();
    }
}

2.懒汉模式

public class singal2 {
    static class singalton{
        private singalton(){}
        private static singalton instance=null;
        public static singalton getInstance(){
            if(instance==null){
                instance=new singalton();
            }
            return instance;
        }
    }

3.区别

我们在对比代码的时候不难发现懒汉模式有了一个判断条件，如果这个条件符合才会new出对象，而饿汉模式是直接new出的对象，所以我们不难看出懒汉模式的的效率是更高的。

但是我们仔细考虑一下，在多个线程的模式下，同时运行懒汉模式，他们就会同时把这个判断值读取到cpu中，从而会new出多个对象，从而违反了单例模式的设计准则；

4.优化懒汉模式 

在上面对的情况我们可以很容易解决，我们可以在上面进行加锁，从而可以达到我们的目的。

所以可以推出懒汉pro版本

//pro版本:加锁
    static class singalton2{
        private singalton2(){}
        private static singalton2 instance=null;
        public static singalton2 getInstance(){
            //确保这的判断和修改的原子性
            synchronized(singalton2.class){
                if (instance == null) {
                    instance = new singalton2();
                }
            }
            return instance;
        }
    }

但是我们想一下，加锁必定会降低效率，那么我们就可以考虑优化一下效率，那如何进行优化呢，我们可以在获取锁前利用判断值判断一下是否已经不需要获取锁了。

懒汉pro max版本

 //加入了锁必定会降低效率，所以需要提前判断一下instance的值
    static class singalton3{
        private singalton3(){}
        private static singalton3 instance=null;
        public static singalton3 getInstance() {
            //确保这的判断和修改的原子性
            if (instance==null) {
                synchronized (singalton3.class) {
                    if (instance == null) {
                        instance = new singalton3();
                    }
                }
            }
            return instance;
        }
    }

优化到这了，我们在再仔细想一下，是否线程还安全，所以考虑一下这个instance，由于涉及多个读取操作，可能会被编译器进行优化，若是多个线程进行操作，可能会发生内存不可见问题，所以我们可以用volatile来进行修饰一下instance。

懒汉pro max ultra版本

 static class singalton4{
        private singalton4(){}
        private volatile static singalton4 instance=null;
        public static singalton4 getInstance() {
            //确保这的判断和修改的原子性
            if (instance==null) {
                synchronized (singalton4.class) {
                    if (instance == null) {
                        instance = new singalton4();
                    }
                }
            }
            return instance;
        }
    }