今天做了一套java的面试题,里面出现了单例模式的设计,所以把以前的单例模式复习一下,顺便分享给大家
//单例模式 (Singleton)
//如果要保证系统里一个类最多只能存在一个实例时,我们就须要单例模式。这种情况在应用中经常碰到,例如缓存池,
//数据库连接池,线程池,一些应用服务实力等。在多线程的环境中,为了保证实例的唯一性其实并不简单。
/*
* 最简单的单例模式
* 为了限制该类的对象被随意的创建,须要保证该类的构造方法时私有的,这样外部类就无法创建该类型的对象了
* 另外为了方便给客户对象提供次单例对象的使用,我们须要给他提供一个全局访问点
*/
/*
* 此时线程是安全的,当多个线程去访问getInstance()方法时,不会初始化多个不同的对象,这是因为
* JVM在加载此类时,对static属性的初始化只能由一个线程执行且仅依次。
* 客户使用该单例模式方法也非常简单
* SingletonModel singleton = Sigleton.getInstance();
*/
/*
* 单例模式的进阶
* 如果时处于性能的考虑,在进行初始化类时并不进行实例化对象(static属性在加载类时就会被初始化),
* 只有在第一次实例时才去实例化,那么该怎么办呢
* 延迟创建的单例模式
*/
/*
* 上面的延迟创建实例中是线程不安全的,在高并发的环境中是会出现多个不同的实例对象的,如果这是在c++
* 编写此模式,因为我们认为创建了一个单实例,忽略了其它线程所产生的对象,不会手动去回收他们,于是就
* 产生了内存泄漏。
* 如果要解决这个问题,须要给此方法加上synchronized关键字,代码如下
*/
/*
* Double-Check Locking
* 上面虽然实现的多线程访问的安全,但是在多线程的高并发访问的情况下,给此方法添加synchronized
* 关键字会使得性能大不如前。
* 使用关键字synchronized关键字对整个getInstance()方法进行同步是没有必要的:我们只要保证实例化
* 这个对象的那段逻辑被一个线程执行就可以了,而返回的那段代码是没有必要同步的。按照这个想法实现的
* 代码如下
*/
* 正式由于使用了两次的检查,我们称之为double-check locking
* 属性instance是被volatile修饰的,因为volatile具有synchronized的可见性特点,也就是说
* 线程能够自动的发现volatile变量的最新值,这样如果实例化成功那么其它线程就可以发现。
*/
/*
* Initialization on demand holder懒人加载模式
* 实现代码如下
*/
* 当JVM加载LazyLoadedSingleton类时,由于该类没有static属性,所有加载完成后便即可返回。
* 只有第一次调用getInstance()方法是,JVM才会加载LazyHolder类,由于它包含一个static属性singletonInstance
* ,所以会先初始化这个变量,根据前面多讲JVM只能让一个线程来对static进行初始化。这样就实现
* 了一个既保证线程安全有支持延迟加载的单例模式。
*/
//单例模式 (Singleton)
//如果要保证系统里一个类最多只能存在一个实例时,我们就须要单例模式。这种情况在应用中经常碰到,例如缓存池,
//数据库连接池,线程池,一些应用服务实力等。在多线程的环境中,为了保证实例的唯一性其实并不简单。
/*
* 最简单的单例模式
* 为了限制该类的对象被随意的创建,须要保证该类的构造方法时私有的,这样外部类就无法创建该类型的对象了
* 另外为了方便给客户对象提供次单例对象的使用,我们须要给他提供一个全局访问点
*/
public class SingletonModel {
private static SingletonModel instance = new SingletonModel();
private SingletonModel(){}
//提供全局访问点,必须用public static属性
public static SingletonModel getInstance(){
return instance;
}
}
/*
* 此时线程是安全的,当多个线程去访问getInstance()方法时,不会初始化多个不同的对象,这是因为
* JVM在加载此类时,对static属性的初始化只能由一个线程执行且仅依次。
* 客户使用该单例模式方法也非常简单
* SingletonModel singleton = Sigleton.getInstance();
*/
/*
* 单例模式的进阶
* 如果时处于性能的考虑,在进行初始化类时并不进行实例化对象(static属性在加载类时就会被初始化),
* 只有在第一次实例时才去实例化,那么该怎么办呢
* 延迟创建的单例模式
*/
class UnThreadSafeSingleton{
private static UnThreadSafeSingleton instance = null;
private UnThreadSafeSingleton(){}
public static UnThreadSafeSingleton getInstance(){
if(instance == null){ //这句判断并不是线程安全的
instance = new UnThreadSafeSingleton();
}
return instance;
}
}
/*
* 上面的延迟创建实例中是线程不安全的,在高并发的环境中是会出现多个不同的实例对象的,如果这是在c++
* 编写此模式,因为我们认为创建了一个单实例,忽略了其它线程所产生的对象,不会手动去回收他们,于是就
* 产生了内存泄漏。
* 如果要解决这个问题,须要给此方法加上synchronized关键字,代码如下
*/
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()方法进行同步是没有必要的:我们只要保证实例化
* 这个对象的那段逻辑被一个线程执行就可以了,而返回的那段代码是没有必要同步的。按照这个想法实现的
* 代码如下
*/
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进行初始化。这样就实现
* 了一个既保证线程安全有支持延迟加载的单例模式。
*/