单例模式的四种实现方法

核心作用

保证一个类只有一个实例，并且对外提供一个访问该实例的一个接口。

常见应用场景

• Windows的任务管理器，回收站
• 数据库连接池
• Servlet
• Spring中，每个bean默认是单例的

实现方式

饿汉式（线程安全，调用效率高，但是，不能延时加载）

public class Singleton {
	//类初始化时，立即加载这个对象(没有延时加载的优势)
	private static Singleton instance = new Singleton(); 
	
	private Singleton(){} //私有化构造器
 
	//方法没有同步，调用效率高
	public static Singleton getInstance(){
		return instance;
	}
}

 

懒汉式（线程安全，调用效率不高，但是，可以延时加载）

public class Singleton {
	//类初始化时，不初始化对象，只有当真正用的时候在加载(延时加载)
	private static Singleton instance; 
	
	private Singleton(){} //私有化构造器
	
	//方法同步，调用效率不高
	public static synchronized Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}	
		return instance; 
	}
}

 

静态内部类（线程安全，调用效率高，并且延时加载）

package com.ck.singleton;

public class Singleton {
	
	private static class SingletonClassInstance{
		private static final Singleton instance = new Singleton(); 
	}
	
	private Singleton(){} //私有化构造器
	
	//方法没有同步，调用效率高
	public static Singleton getInstance(){
		return SingletonClassInstance.instance;
	}
}

双重检查锁

public class Singleton {

    /**
     * 一开始不进行对象的创建
     * volitile 能够防止指令重排序
     */
    private static volatile Singleton instance;


    private Singleton(){};

    /**
     * 当使用的时候才去创建对象
     * @return 对象实例
     */
    public static Singleton getInstance(){
        if(null == instance){
            synchronized(Singleton.class){
                if(null == instance){
                    //这里会出现指令重排序，因为new要分为三步骤，所以要使用volitile关键字禁止重排
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

在多线程环境下的测试效率

饿汉式	22ms
懒汉式	636ms
静态内部类	28ms
双重检查锁	65ms