许文杰的博客

欢迎来到我的博客

剑指offer第二版面试题2:实现Singleton模式(java)

1、题目:

设计一个类,我们只能生成该类的一个实例。

2、题目分析

只能生成一个实例的类是实现了Singleton(单例)模式的类型。

3、解法一:懒汉式单例

懒汉式单例模式在第一次调用的时候进行实例化。

3.1 只适用于单线程环境的单例模式

由于要求只能生成一个实例,因此我们必须把构造函数设为私有函数以禁止他人创建实例。可以定义一个静态的实例,在需要的时候创建该实例。

public class Singleton {
    private static Singleton instance= null;
    //构造函数设计为私有的,以禁止在其他类中创建实例
    private Singleton(){

    }
    public static Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }


    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        Singleton s2 = s;
        Singleton s3 = Singleton.getInstance();
        System.out.println(s == s2);
        System.out.println(s == s3);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

上述代码在Singleton类的静态属性instance中,只有在instance为null的时候才创建一个实例以避免重复创建。同时我们把构造函数定义为私有函数,这样就能确保只创建一个实例。

可以运行main函数看到结果为,两个true。说明两次调用Singleton类的getInstance()方法,却只创建了一个实例。

3.2 可以在多线程环境中工作,但效率不高的单例模式

解法一中的代码在单线程的时候工作正常,但在多线程的情况下就有问题了。设想如果两个线程同时运行到判断instance是否为null的if语句,并且instance的确没有创建时,那么两个线程都会创建一个实例,此时类型Singleton就不再满足单例模式的要求了。

为了保证在多线程环境下我们还是只能得到该类的一个实例,只需要在getInstance()方法加上同步关键字sychronized,就可以了。

public static synchronized Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instance;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

这样需要可以实现在多线程环境保证只创建一个实例,但每次调用getInstance()方法时都被synchronized关键字锁住了,会引起线程阻塞,会影响程序的性能。

3.3 双重检查加锁的单例模式

为了在多线程环境下,不影响程序的性能,不让线程每次调用getInstance()方法时都加锁,而只是在实例未被创建时再加锁,在加锁处理里面还需要判断一次实例是否已存在,这种做法被称为“双重检查加锁”。

public static Singleton getInstance() {  
        if (instance == null) {//先判断实例是否存在,若不存在再对类对象进行加锁处理
            synchronized (Singleton.class) {    
               if (instance == null) {    
                   instance = new Singleton();   
               }    
            }    
        }    
        return instance;   
    }  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3.4 使用静态内部类实现的单例模式

public class Singleton {
    //构造函数设计为私有的,以禁止在其他类中创建实例
    private Singleton(){

    }
    //静态内部类
    private static class LazyHolder {    
        private static final Singleton INSTANCE = new Singleton();    
     }     
     public static Singleton getInstance() {    
        return LazyHolder.INSTANCE;    
     } 
}    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这种比上面1、2都好一些,既实现了线程安全,又避免了同步带来的性能影响,任何时候都不会发生阻塞。

4、解决二:饿汉式单例

饿汉式单例类:在类初始化时,已经自行实例化

    public class Singleton1 {  
        private Singleton1() {}  
        private static final Singleton1 single = new Singleton1();  
        //静态工厂方法   
        public static Singleton1 getInstance() {  
            return single;  
        }  
    }  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。

5、饿汉式单例与懒汉式单例的比较

  • 饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,

  • 懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。

5.1 从以下两点再区分以下这两种方式:

1、线程安全:

  • 饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,

  • 懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能:

  • 饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,

  • 懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_37672169/article/details/79964488
文章标签: 算法
个人分类: 算法 java基础
上一篇java线程中join方法的简单讲解
下一篇剑指offer第二版面试题3:数组中重复的数字(java)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭