单例模式的懒汉饿汉

单例模式的三个特点：

　　1. 私有构造方法；

　　2. 内部创建静态对象；

　　3. 提供静态方法返回该静态对象；

单例设计模式主要有两种实现方法：饿汉式和懒汉式

　　饿汉式单例：在定义开始，便实例化自己。

class Singleton0 {
    
    //构造方法私有化
    private Singleton0() {
        
    }
    //内部创建静态对象并实例化
    private static Singleton0 s=new Singleton0();
    //提供静态方法返回该静态对象
    public static Singleton0 getsingle() {
        return s;
    }
    
}

　　懒汉式单例：在第一次调用时实例化自己。

class Singleton1{
    
    //构造方法私有化
    private Singleton1() {
        
    }
    //内部创建静态对象
    public static Singleton1 single=null;
    //提供静态方法返回该静态对象
    public static Singleton1 getsingle() {
        //静态对象实例化
        single=new Singleton1();
        return single;
    }
    
}

　　懒汉式与饿汉式的区别：

　　　　1. 线程安全：

　　　　　　饿汉式天生线程安全，可以直接用于多线程而不会出现问题。

　　　　　　懒汉式本身非线程安全，需要人为实现线程安全。

　　　　2. 资源加载和性能：

　　　　　　饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，造成内存泄漏，但相应的，在第一次调用时速度也会更快。

　　　　　　懒汉式会延迟加载，加载前不占用内存，在第一次使用该单例的时候才会实例化对象，且第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

　　　保证懒汉式线程安全的三种方法：

　　　　　　1. 全局访问点加同步：由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之，不管对象有没有被创建，其余线程都只能等待这个方法的锁。

class Single1{
    private Single1() {
        //私有构造方法
    }
    public static Single1 s=null;
    public static synchronized Single1 getsingle() {
        s=new Single1();//实例化
        return s;
    }
}

　　　　　　2. 双重检查锁定：由于上述都是在等待同步方法的锁，很容易想到把synchronized放在方法里面，这样可以避免方法的阻塞。

class Single2{
    private Single2() {
        //私有构造方法
    }
    public static Single2 s=null;
    public static Single2 getsingle() {
        if(s==null) {
            synchronized(Single2.class) {
                    s=new Single2();//实例化
            }
        }
        return s;
    }
}

　　　　　　这种写法看似没有问题, 其实却有一个很大的隐患, 在于：如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null，所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:

class Single3{
    private Single3() {
        //私有构造方法
    }
    public static Single3 s=null;
    public static Single3 getsingle() {
        if(s==null) {
            synchronized(Single3.class) {
                if(s==null) {
                    s=new Single3();//实例化
                }
            }
        }
        return s;
    }
}

　　　　　　3. 静态内部类：既实现了线程安全，又避免了同步带来的性能影响。

原文：https://blog.csdn.net/sinat_33057149/article/details/78218146