剑指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);
    }
}

上述代码在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;
    }

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

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

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

public static Singleton getInstance() {  
        if (instance == null) {//先判断实例是否存在，若不存在再对类对象进行加锁处理
            synchronized (Singleton.class) {    
               if (instance == null) {    
                   instance = new Singleton();   
               }    
            }    
        }    
        return instance;   
    }

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都好一些，既实现了线程安全，又避免了同步带来的性能影响，任何时候都不会发生阻塞。

4、解决二：饿汉式单例

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

     public class Singleton1 {  
        private Singleton1() {}  
        private static final Singleton1 single = new Singleton1();  
        //静态工厂方法   
        public static Singleton1 getInstance() {  
            return single;  
        }  
    }

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

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

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

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

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

1、线程安全：

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

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

2、资源加载和性能：

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

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

原文出处