java常见面试题之单例模式

java之单例模式

提起单例模式，相信这是很多面试题中都会出现的一个题，大家也基本了解，但是怎么做才能让面试官对你刮目相看呢？？那么接下来我们来进行解析单例模式，填充你的知识库

先说最简单的单例模式：

package com.youzhong.test;

public class SingletonModel {

	private static SingletonModel instance = new SingletonModel();  
    
    private SingletonModel(){}  
    //提供全局访问点，必须用public static属性  
    public static SingletonModel getInstance(){  
        return instance;  
    }  
	public static void main(String[] args) {
		SingletonModel danli = SingletonModel.getInstance();
	}
	
}

为了限制该类的对象被随意的创建，须要保证该类的构造方法时私有的，这样外部类就无法创建该类型的对象了

另外为了方便给客户对象提供次单例对象的使用，我们须要给他提供一个全局访问点，用 public static 修饰

此时线程是安全的，当多个线程去访问getInstance()方法时，不会初始化多个不同的对象，

这是因为JVM在加载此类时，对static属性的初始化只能由一个线程执行且仅一次。

客户使用该单例模式方法也非常简单

SingletonModel singleton = Sigleton.getInstance();

看似很简单的单例模式但是如果要保证系统里一个类最多只能存在一个实例时，我们就须要单例模式。

这种情况在应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实力等。

在多线程的环境中，为了保证实例的唯一性其实并不简单。

来一个单例模式的升级版

如果时处于性能的考虑，在进行初始化类时并不进行实例化对象(static属性在加载类时就会被初始化)，

只有在第一次实例时才去实例化，那么该怎么办呢

延迟创建的单例模式：

package com.youzhong.test;

class UnThreadSafeSingleton{  
	private static UnThreadSafeSingleton instance = null;  
	private UnThreadSafeSingleton(){}  
	  
	public static UnThreadSafeSingleton getInstance(){  
		if(instance == null){ //这句判断并不是线程安全的  
			instance = new UnThreadSafeSingleton();  
		}  
		return instance;  
	}  
}

上面的延迟创建实例中是线程不安全的，在高并发的环境中是会出现多个不同的实例对象的，如果这是在c++

编写此模式，因为我们认为创建了一个单实例，忽略了其它线程所产生的对象，不会手动去回收他们，于是就产生了内存泄漏。

如果要解决这个问题，须要给此方法加上synchronized关键字，代码如下

package com.youzhong.test;

class ThreadSafeSingleton{  
	private static ThreadSafeSingleton instance = null;  
	private ThreadSafeSingleton(){}  
	  
	//这样，在多的线程访问都只会实例化一个对象  
	public synchronized static ThreadSafeSingleton getInstance(){  
		if(instance == null){  
			instance = new ThreadSafeSingleton();  
		}  
		return instance;  
	}  
}  

Double-Check Locking

上面虽然实现的多线程访问的安全，但是在多线程的高并发访问的情况下，给此方法添加synchronized

关键字会使得性能大不如前。

使用关键字synchronized关键字对整个getInstance()方法进行同步是没有必要的:我们只要保证实例化

这个对象的那段逻辑被一个线程执行就可以了，而返回的那段代码是没有必要同步的。按照这个想法实现的

代码如下：

package com.youzhong.test;

class DoubleCheckSingleton{  
	private volatile static DoubleCheckSingleton instance = null;  
	
	private DoubleCheckSingleton(){}  
	
	public static DoubleCheckSingleton getInstacne(){  
	
		if(instance == null){  
		  synchronized(DoubleCheckSingleton.class){  
			  //Double Check if it is create  
			  if(instance == null){  
				  instance = new DoubleCheckSingleton();  
			  }  
		  }  
		}  
		return instance;  
	}  
} 

正式由于使用了两次的检查，我们称之为double-check locking

属性instance是被volatile修饰的，因为volatile具有synchronized的可见性特点，

也就是说线程能够自动的发现volatile变量的最新值，这样如果实例化成功那么其它线程就可以发现。

Initialization on demand holder懒人加载模式

实现代码如下：

class LazyLoadedSingleton{  
	  
	private LazyLoadedSingleton(){}  
	  
	private static class LazyHolder{  
		private static final LazyLoadedSingleton singletonInstance = new LazyLoadedSingleton();  
	}  
	public static LazyLoadedSingleton getInstance(){  
		return LazyHolder.singletonInstance;  
	}  
} 

当JVM加载LazyLoadedSingleton类时，由于该类没有static属性，所有加载完成后便即可返回。

只有第一次调用getInstance()方法是，JVM才会加载LazyHolder类，

由于它包含一个static属性singletonInstance，所以会先初始化这个变量，根据前面多讲JVM只能让一个线程来对static进行初始化。

这样就实了一个既保证线程安全有支持延迟加载的单例模式。

一次倾听~

一次收获~

愿你有高跟鞋也有跑鞋~

喝酒也喝茶~