单列模式的应用场景
- 单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点。单例模式是创建新模式。J2EE标准中的ServletContext、ServletContextConfig 等、Spring 框架应用中的ApplictionContext、数据库的连接池等都是单例形式。
饿汉式单例模式
- 先来看单例模式的类结构图,如图
-
饿汉式单例模式在类加载的时候立即初始化,并且创建单例对象。它是绝对线程安全,在线程还没出现以前就实例化了,不可能存在线程安全问题。
优点: 没有加任何锁、执行效率比较高,用户体验比懒汉式单例模式好。
缺点: 类加载的时候就初始化,不管用不用都占用空间,浪费了内存。
-
Spring 中Ioc 容器ApplicationContext本身就是典型的饿汉式单例模式,接下来看一段代码。
public class HungrySingleton {
private static final HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();
private HungrySingleton(){
}
public static HungrySingleton getInstance(){
return HUNGRY_SINGLETON;
}
}
- 还有另一种写法静态代码块机制
public class HungryStaticSingleton {
private static final HungryStaticSingleton HUNGRY_SINGLETON;
static {
HUNGRY_SINGLETON = new HungryStaticSingleton();
}
private HungryStaticSingleton(){
}
public static HungryStaticSingleton getInstance(){
return HUNGRY_SINGLETON;
}
}
- 这两种写法都非常简单,也非常好理解,饿汉式单例模式适用于单例对象比较少的情况,下面我们看性能更优的写法。
懒汉式单例模式
- 懒汉式单例模式的特点是:被外部类调用的时候内部类才会加载。下面看懒汉模式的简单实现
//懒汉式单例模式在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
private static LazySimpleSingleton LAZY_SIMPLE_SINGLETON = null;
private LazySimpleSingleton(){}
public static LazySimpleSingleton getInstance(){
if(LAZY_SIMPLE_SINGLETON == null){
LAZY_SIMPLE_SINGLETON = new LazySimpleSingleton();
}
return LAZY_SIMPLE_SINGLETON;
}
}
- 然后我们写一个线程类
public class ExectorThread implements Runnable {
@Override
public void run() {
LazySimpleSingleton lazySimpleSingleton = LazySimpleSingleton.getInstance();
System.out.println(Thread.currentThread().getName()+":"+ lazySimpleSingleton);
}
}
- 测试代码
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();
}
}
- 运行结果:
- 上面的代码一定概率出现两种不同的结果,意味着上面的单例模式存在安全隐患。那么我们怎样优化代码才能使得懒汉式单例模式线程安全呢?来看代码我们在getInstance()方法加上synchronized关键字,使这个方法变成线程同步方法。
public class LazySimpleSingleton {
private static LazySimpleSingleton lazy = null;
private LazySimpleSingleton(){}
public synchronized static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}
- 虽然线程安全问题解决了,但是用synchronized加锁时,在线程数量比较多的情况下,如果cpu分配压力上升,则会导致线程阻塞,性能大幅下降,我们引入一种新的方式,双重加锁
public class LazySimpleSingleton {
private volatile static LazySimpleSingleton lazy = null;
private LazySimpleSingleton(){}
public static LazySimpleSingleton getInstance(){
if(lazy == null){
synchronized (LazySimpleSingleton.class){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
}
}
return lazy;
}
}
- 优化后的结果是代码块的阻塞,逻辑不复杂的情况下感知较小。但是用到synchronized 关键字总归要上锁,看下边一种写法,采用静态内部类:
//这种形式兼顾了饿汉式单例模式的内存浪费问题 和sychronized 的性能问题
public class LazyInnerClassSingleton {
//使用LazyInnerClassSingleton的时候,默认会先初始化内部类
//入股没使用则内部类是不加载的
private LazyInnerClassSingleton(){}
//static 关键字是为了使单例的空间共享,不会被重写,重载
public static final LazyInnerClassSingleton getInstance (){
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
- 这种方式兼顾了饿汉式单例模式的内存浪费问题和synchronized的性能问题,内部类一定要在方法调用之前初始化,巧妙的避免了线程安全问题。
- 下期:单例模式详解二 以及更优的单例模式。谢谢。