单例模式的应用场景 单例模式(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 HungrySingletonStatic {
private static final HungrySingletonStatic hungrySingleton;
static {
hungrySingleton = new HungrySingletonStatic();
}
private HungrySingletonStatic(){}
public static HungrySingletonStatic getInstance(){
return hungrySingleton;
}
}
这两种写法都非常的简单,也非常好理解,饿汉式适用在单例对象较少的情况。
懒汉式单例
懒汉式单例的特点是:被外部类调用的时候内部类才会加载,下面看懒汉式单例的简单 实现 LazySimpleSingleton:
/**
* 懒汉式
*/
public class LazySimpleSingleton {
private static LazySimpleSingleton lazy=null;
private LazySimpleSingleton(){}
public synchronized static LazySimpleSingleton getInstance(){
if (lazy==null){
return new LazySimpleSingleton();
}
return lazy;
}
}
public class ExectorThread implements Runnable{
@Override
public void run() {
// LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
// LazyDoubleCheckSingleton singleton= LazyDoubleCheckSingleton.getInstance();
// Object object=ContainerSingleton.getBean("com.design.pattern.singleton.containersingleton.Test");
//System.out.println(Thread.currentThread().getName() + ":" + object.toString());
System.out.println(ThreadLocalSingleton.getInstance());
System.out.println(ThreadLocalSingleton.getInstance());
}
}
客户端测试代码:
/**
* 懒汉式测试类
*/
public class LazySimpleSingletonTest {
public static void main(String[] args) {
Thread thread1=new Thread(new ExectorThread());
Thread thread2=new Thread(new ExectorThread());
thread1.start();
thread2.start();
System.out.println("结束");
}
}
测试结果:
一定几率出现创建两个不同结果的情况,意味着上面的单例存在线程安全隐患。现在我们用调试运行再具体看一下,教给大家一个新技能,用线程模式调试,手动控制线程的执行顺序来跟踪内存的变化状态。先给 ExectorThread 类打上断点:
右键点击断点,切换为 Thread 模式,如下图:
然后,给 LazySimpleSingleton 类打上断点,同样标记为 Thread 模式:
切回到客户端测试代码,同样也打上断点,同时改为 Thread 模式,如下图
开始 debug 之后,会看到 debug 控制台可以自由切换 Thread 的运行状态:
通过不断切换线程,并观测其内存状态,我们发现在多线程环境下 LazySimpleSingleton被实例化了两次。有时,我们得到的运行结果可能是相同的两个对象,实际上是被后面执行的线程覆盖了,我们看到了一个假象,线程安全隐患依旧存在。那么,我们如何来优化代码,使得懒汉式单例在线程环境下安全呢?来看下面的代码,给 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 监视锁,线程安全的问题便解决了。但是,用synchronized 加锁,在线程数量比较多情况下,如果 CPU 分配压力上升,会导致大批量线程出现阻塞,从而导致程序运行性能大幅下降。那么,有没有一种更好的方式,既兼顾线程安全又提升程序性能呢?答案是肯定的。我们来看双重检查锁的单例模式:
双重检查锁模式
/**
* 双重检查锁
*/
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private volatile static LazyDoubleCheckSingleton lazy = null;
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 性能问题。内部类一定是要在方法调用之前初始化,巧妙地避免了线程安全问题。