单例模式的应用场景
单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例,并
提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。
例如, 国家主席、公司CEO 、部门经理等。在J2EE 标准中, ServletContext 、
ServletContextConfig 等;在Spring 框架应用中ApplicationContext;数据库的连接
池也都是单例形式。
饿汉式单例
先来看单例模式的类结构图:
饿汉式单例是在类加载的时候就立即初始化,并且创建单例对象。绝对线程安全,在线
程还没出现以前就是实例化了,不可能存在访问安全问题。
优点:没有加任何的锁、执行效率比较高,在用户体验上来说,比懒汉式更好。
缺点:类加载的时候就初始化,不管用与不用都占着空间,浪费了内存。
Spring 中IOC 容器ApplicationContext 本身就是典型的饿汉式单例。接下来看一段代
码:
public class HungrySingleton {
//先静态、后动态
//先属性、后方法
//先上后下
private static final HungrySingleton hungrySingleton = new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
还有另外一种写法,利用静态代码块的机制:
//饿汉式静态块单例
public class HungryStaticSingleton {
private static final HungryStaticSingleton hungrySingleton;
static {
hungrySingleton = new HungryStaticSingleton();
}
private HungryStaticSingleton(){}
public static HungryStaticSingleton getInstance(){
return hungrySingleton;
}}
这两种写法都非常的简单,也非常好理解,饿汉式适用在单例对象较少的情况。下面我
们来看性能更优的写法。
懒汉式单例
懒汉式单例的特点是:被外部类调用的时候内部类才会加载,下面看懒汉式单例的简单
实现LazySimpleSingleton:
//懒汉式单例
//在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块,公共内存区域
private static LazySimpleSingleton lazy = null;
public static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;}}
懒汉式单例存在线程安全问题:
写一个线程类ExectorThread 类:
public class ExectorThread implements Runnable{
@Override
public void run() {
LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + ":" + singleton);
}}
客户端测试代码:
public class LazySimpleSingletonTest {
public static void main(String[] args) {
Thread t1 = new Thread(new ExectorThread());
Thread t2 = new Thread(new ExectorThread());
t1.start();
t2.start();
System.out.println("End");
}}
运行结果:
那么,我们如何来
优化代码,使得懒汉式单例在线程环境下安全呢?来看下面的代码,给getInstance()加
上synchronized 关键字,是这个方法变成线程同步方法:
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块,公共内存区域
private static LazySimpleSingleton lazy = null;
public synchronized static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}
这时候,我们再来调试。当我们将其中一个线程执行并调用getInstance()方法时,另一
个线程在调用getInstance()方法,线程的状态由RUNNING 变成了MONITOR,出现阻
塞。直到第一个线程执行完,第二个线程才恢复RUNNING 状态继续调用getInstance()
方法。
但是,用synchronized 加锁,在线程数量比较多情况下,如果CPU 分配压力上升,会导致大批
量线程出现阻塞,从而导致程序运行性能大幅下降。那么,有没有一种更好的方式,既
兼顾线程安全又提升程序性能呢?答案是肯定的。我们来看双重检查锁的单例模式:
public class LazyDoubleCheckSingleton {
private volatile static LazyDoubleCheckSingleton lazy = null;
private LazyDoubleCheckSingleton(){}
public static LazyDoubleCheckSingleton getInstance(){
if(lazy == null){
synchronized (LazyDoubleCheckSingleton.class){
if(lazy == null){
lazy = new LazyDoubleCheckSingleton();
//1.分配内存给这个对象
//2.初始化对象
//3.设置lazy 指向刚分配的内存地址
}
}
}
return lazy;
}
}
当第一个线程调用getInstance()方法时,第二个线程也可以调用getInstance()。当第一
个线程执行到synchronized 时会上锁,第二个线程就会变成MONITOR 状态,出现阻
塞。此时,阻塞并不是基于整个LazySimpleSingleton 类的阻塞,而是在getInstance()
方法内部阻塞,只要逻辑不是太复杂,对于调用者而言感知不到。
但是,用到synchronized 关键字,总归是要上锁,对程序性能还是存在一定影响的。难
道就真的没有更好的方案吗?当然是有的。我们可以从类初始化角度来考虑,看下面的
代码,采用静态内部类的方式:
//这种形式兼顾饿汉式的内存浪费,也兼顾synchronized 性能问题
//完美地屏蔽了这两个缺点
public class LazyInnerClassSingleton {
//默认使用LazyInnerClassGeneral 的时候,会先初始化内部类
//如果没使用的话,内部类是不加载的
private LazyInnerClassSingleton(){}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写,重载
public static final LazyInnerClassSingleton getInstance(){
//在返回结果以前,一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
这种形式兼顾饿汉式的内存浪费,也兼顾synchronized 性能问题。内部类一定是要在方
法调用之前初始化,巧妙地避免了线程安全问题。
最后反射和序列化都会破坏线程,关于这一部分原理以及避免方法我会另外再写一篇文章介绍