单例模式的懒汉饿汉

xiaoemo0 2019-11-01

单例模式的三个特点:

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

相关推荐