经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » 设计模式 » 查看文章
设计模式 - 单例模式(详解)看看和你理解的是否一样?
来源:cnblogs  作者:EamonZzz  时间:2019/10/8 9:27:43  对本文有异议

一、概述

单例模式是设计模式中相对简单且非常常见的一种设计模式,但是同时也是非常经典的高频面试题,相信还是有很多人在面试时会挂在这里。本篇文章主要针对单例模式做一个回顾,记录单例模式的应用场景、常见写法、针对线程安全进行调试(看得见的线程)以及总结。相信大家看完这篇文章之后,对单例模式有一个非常深刻的认识。

文章中按照常见的单例模式的写法,由浅入深进行讲解记录;以及指出该写法的不足,从而进行演进改造。

秉承废话少说的原则,我们下面快速开始

二、定义

单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点。

单例模式是创建型模式。

三、应用场景

  1. 生活中的单例:例如,国家主席、公司 CEO、部门经理等。
  2. Java世界中:ServletContextServletContextConfig 等;
  3. Spring 框架应用中:ApplicationContext、数据库的连接池也都是单例形式。

四、常见的单例模式写法

单例模式主要有:饿汉式单例、懒汉式单例(线程不安全型、线程安全型、双重检查锁类型、静态内部类类型)、注册式(登记式)单例(枚举式单例、容器式单例)、ThreadLocal线程单例

下面我们来看看各种模式的写法。

1、饿汉式单例

饿汉式单例是在类加载的时候就立即初始化,并且创建单例对象。绝对线程安全,在线程还没出现以前就是实例化了,不可能存在访问安全问题。

Spring 中 IOC 容器 ApplicationContext 就是典型的饿汉式单例

优缺点

优点:没有加任何的锁、执行效率比较高,在用户体验上来说,比懒汉式更好。

缺点:类加载的时候就初始化,不管用与不用都占着空间,浪费了内存,有可能占着茅坑不拉屎。

写法

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午9:26
  4. */
  5. public class HungrySingleton {
  6. // 1.私有化构造器
  7. private HungrySingleton (){}
  8. // 2.在类的内部创建自行实例
  9. private static final HungrySingleton instance = new HungrySingleton();
  10. // 3.提供获取唯一实例的方法(全局访问点)
  11. public static HungrySingleton getInstance(){
  12. return instance;
  13. }
  14. }

还有另外一种写法,利用静态代码块的机制:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午10:46
  4. */
  5. public class HungryStaticSingleton {
  6. // 1. 私有化构造器
  7. private HungryStaticSingleton(){}
  8. // 2. 实例变量
  9. private static final HungryStaticSingleton instance;
  10. // 3. 在静态代码块中实例化
  11. static {
  12. instance = new HungryStaticSingleton();
  13. }
  14. // 4. 提供获取实例方法
  15. public static HungryStaticSingleton getInstance(){
  16. return instance;
  17. }
  18. }

测试代码,我们创建 10 个线程(具体线程发令枪 ConcurrentExecutor 在文末源码中获取):

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午11:17
  4. */
  5. public class HungrySingletonTest {
  6. @Test
  7. public void test() {
  8. try {
  9. ConcurrentExecutor.execute(() -> {
  10. HungrySingleton instance = HungrySingleton.getInstance();
  11. System.out.println(Thread.currentThread().getName() + " : " + instance);
  12. }, 10, 10);
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }

测试结果:

  1. pool-1-thread-6 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  2. pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  3. pool-1-thread-9 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  4. pool-1-thread-10 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  5. pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  6. pool-1-thread-7 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  7. pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  8. pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  9. pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  10. pool-1-thread-8 : com.eamon.javadesignpatterns.singleton.hungry.HungrySingleton@5e37cce6
  11. ...

可以看到,饿汉式每次获取实例都是同一个。

使用场景

这两种写法都非常的简单,也非常好理解,饿汉式适用在单例对象较少的情况。

下面我们来看性能更优的写法——懒汉式单例。


2、懒汉式单例

懒汉式单例的特点是:被外部类调用的时候内部类才会加载。

懒汉式单例可以分为下面这几种写法来。

简单懒汉式(线程不安全)

这是懒汉式单例的简单写法

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午10:55
  4. */
  5. public class LazySimpleSingleton {
  6. private LazySimpleSingleton(){}
  7. private static LazySimpleSingleton instance = null;
  8. public static LazySimpleSingleton getInstance(){
  9. if (instance == null) {
  10. instance = new LazySimpleSingleton();
  11. }
  12. return instance;
  13. }
  14. }

我们创建一个多线程来测试一下,是否线程安全:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午11:12
  4. */
  5. public class LazySimpleSingletonTest {
  6. @Test
  7. public void test() {
  8. try {
  9. ConcurrentExecutor.execute(() -> {
  10. LazySimpleSingleton instance = LazySimpleSingleton.getInstance();
  11. System.out.println(Thread.currentThread().getName() + " : " + instance);
  12. }, 5, 5);
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }

运行结果:

  1. pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
  2. pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
  3. pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@748e48d0
  4. pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f
  5. pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.lazy.LazySimpleSingleton@abe194f

从测试结果来看,一定几率出现创建两个不同结果的情况,意味着上面的单例存在线程安全隐患。

至于为什么?由于篇幅问题,我们在后面一篇文章中利用测试工具进行详细的分析(这可能也是面试中面试官会问到的问题)。大家现在只需要知道简单的懒汉式会存在这么一个问题就行了。

简单懒汉式(线程安全)

通过对上面简单懒汉式单例的测试,我们知道存在线程安全隐患,那么,如何来避免或者解决呢?

我们都知道 java 中有一个synchronized可以来对共享资源进行加锁,保证在同一时刻只能有一个线程拿到该资源,其他线程只能等待。所以,我们对上面的简单懒汉式进行改造,给getInstance() 方法加上synchronized

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 上午10:55
  4. */
  5. public class LazySimpleSyncSingleton {
  6. private LazySimpleSyncSingleton() {
  7. }
  8. private static LazySimpleSyncSingleton instance = null;
  9. public synchronized static LazySimpleSyncSingleton getInstance() {
  10. if (instance == null) {
  11. instance = new LazySimpleSyncSingleton();
  12. }
  13. return instance;
  14. }
  15. }

然后使用发令枪进行测试:

  1. @Test
  2. public void testSync(){
  3. try {
  4. ConcurrentExecutor.execute(() -> {
  5. LazySimpleSyncSingleton instance = LazySimpleSyncSingleton.getInstance();
  6. System.out.println(Thread.currentThread().getName() + " : " + instance);
  7. }, 5, 5);
  8. } catch (Exception e) {
  9. e.printStackTrace();
  10. }
  11. }

进行多轮测试,并观察结果,发现能够获取同一个示例:

  1. pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
  2. pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
  3. pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
  4. pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de
  5. pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.lazy.simple.LazySimpleSyncSingleton@1a7e99de

线程安全问题是解决了,但是,用synchronized加锁,在线程数量比较多情况下,如果CPU分配压力上升,会导致大批量线程出现阻塞,从而导致程序运行性能大幅下降。

那么,有没有一种更好的方式,既兼顾线程安全又提升程序性能呢?答案是肯定的。

我们来看双重检查锁的单例模式。

双重检查锁懒汉式

上面的线程安全方式的写法,synchronized锁是锁在 getInstance() 方法上,当多个线程过来拿资源的时候,其实需要拿的不是getInstance()这个方法,而是getInstance()方法里面的instance 实例对象,而如果这个实例对象一旦被初始化之后,多个线程到达时,就可以利用方法中的 if (instance == null) 去判断是否实例化,如果已经实例化了就直接返回,就没有必要再进行实例化一遍。所以对上面的代码进行改造:

第一次改造:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 下午2:03
  4. */
  5. public class LazyDoubleCheckSingleton {
  6. private LazyDoubleCheckSingleton() {
  7. }
  8. private static LazyDoubleCheckSingleton instance = null;
  9. public static LazyDoubleCheckSingleton getInstance() {
  10. // 这里判断是为了过滤不必要的同步加锁,因为如果已经实例化了,就可以直接返回了
  11. if (instance == null) {
  12. // 如果未初始化,则对资源进行上锁保护,待实例化完成之后进行释放
  13. synchronized (LazyDoubleCheckSingleton.class) {
  14. instance = new LazyDoubleCheckSingleton();
  15. }
  16. }
  17. return instance;
  18. }
  19. }

这种方法行不行?答案肯定是不行,代码中虽然是将同步锁添加到了实例化操作中,解决了每个线程由于同步锁的原因引起的阻塞,提高了性能;但是,这里会存在一个问题:

  • 线程X线程Y同时调用getInstance()方法,他们同时判断instance == null,得出的结果都是为null,所以进入了if代码块了
  • 此时线程X得到CPU的控制权 -> 进入同步代码块 -> 创建对象 -> 返回对象
  • 线程X执行完成了以后,释放了锁,然后线程Y得到了CPU的控制权。同样是 -> 进入同步代码块 -> 创建对象 -> 返回对象

所以我们明显可以分析出来:LazyDoubleCheckSingleton 类返回了不止一个实例!所以上面的代码是不行的!大家可以自行测试,我这里就不进行测试了!

我们再进行改造,经过分析,由于线程X已经实例化了对象,在线程Y再次进入的时候,我们再加一层判断不就可以解决 “这个” 问题吗?确实如此,来看代码:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 下午2:03
  4. */
  5. public class LazyDoubleCheckSingleton {
  6. private LazyDoubleCheckSingleton() {
  7. }
  8. private static LazyDoubleCheckSingleton instance = null;
  9. public static LazyDoubleCheckSingleton getInstance() {
  10. // 这里判断是为了过滤不必要的同步加锁,因为如果已经实例化了,就可以直接返回了
  11. if (instance == null) {
  12. // 如果未初始化,则对资源进行上锁保护,待实例化完成之后进行释放(注意,可能多个线程会同时进入)
  13. synchronized (LazyDoubleCheckSingleton.class) {
  14. // 这里的if作用是:如果后面的进程在前面一个线程实例化完成之后拿到锁,进入这个代码块,
  15. // 显然,资源已经被实例化过了,所以需要进行判断过滤
  16. if (instance == null) {
  17. instance = new LazyDoubleCheckSingleton();
  18. }
  19. }
  20. }
  21. return instance;
  22. }
  23. }

大家觉得经过这样改造是不是就完美了呢?在我们习惯性的“讲道理”的思维模式看来,好像确实没什么问题,但是,程序是计算机在执行;什么意思呢?

instance = new LazyDoubleCheckSingleton(); 这段代码执行的时候,计算机内部并非简单的一步操作,也就是非原子操作,在JVM中,这一行代码大概做了这么几件事情:

  1. instance 分配内存
  2. 调用 LazyDoubleCheckSingleton 的构造函数来初始化成员变量
  3. instance对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 中的即时编译器中存在指令重排序的优化;通俗的来说就是,上面的第二步和第三步的顺序是不能保证的,如果执行顺序是 1 -> 3 -> 2 那么在 3 执行完毕、2 未执行之前,被另外一个线程 A 抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程 A 会直接返回 instance,然后被程序调用,就会报错。

当然,这种情况是很难测试出来的,但是确实会存在这么一个问题,所以我们必须解决它,解决方式也很简单,就是 j 将 instance 加上 volatile 关键字。

所以相对较完美的实现方式是:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 下午2:03
  4. */
  5. public class LazyDoubleCheckSingleton {
  6. private LazyDoubleCheckSingleton() {
  7. }
  8. private static volatile LazyDoubleCheckSingleton instance = null;
  9. public static LazyDoubleCheckSingleton getInstance() {
  10. // 这里判断是为了过滤不必要的同步加锁,因为如果已经实例化了,就可以直接返回了
  11. if (instance == null) {
  12. // 如果未初始化,则对资源进行上锁保护,待实例化完成之后进行释放(注意,可能多个线程会同时进入)
  13. synchronized (LazyDoubleCheckSingleton.class) {
  14. // 这里的if作用是:如果后面的进程在前面一个线程实例化完成之后拿到锁,进入这个代码块,
  15. // 显然,资源已经被实例化过了,所以需要进行判断过滤
  16. if (instance == null) {
  17. instance = new LazyDoubleCheckSingleton();
  18. }
  19. }
  20. }
  21. return instance;
  22. }
  23. }

测试代码见文末说明

静态内部类懒汉式

上面的双重锁检查形式的单例,对于日常开发来说,确实够用了,但是在代码中使用synchronized关键字 ,总归是要上锁,上锁就会存在一个性能问题。难道就没有更好的方案吗?别说,还真有,我们从类初始化的角度来考虑,这就是这里所要说到的静态内部类的方式。

废话不多说,直接看代码:

  1. /**
  2. *
  3. * @author eamon.zhang
  4. * @date 2019-09-30 下午2:55
  5. */
  6. public class LazyInnerClassSingleton {
  7. private LazyInnerClassSingleton() {
  8. }
  9. // 注意关键字final,保证方法不被重写和重载
  10. public static final LazyInnerClassSingleton getInstance() {
  11. return LazyHolder.INSTANCE;
  12. }
  13. private static class LazyHolder {
  14. // 注意 final 关键字(保证不被修改)
  15. private static final LazyInnerClassSingleton INSTANCE = new LazyInnerClassSingleton();
  16. }
  17. }

进行多线程测试:

  1. pool-1-thread-9 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
  2. pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
  3. pool-1-thread-6 : com.eamon.javadesignpatterns.singleton.lazy.inner.LazyInnerClassSingleton@88b7fa2
  4. ...

结果都是同一个对象实例。

结论

这种方式即解决了饿汉式的内存浪费问题,也解决了synchronized 所带来的性能问题

原理

利用的原理就是类的加载初始化顺序:

  1. 当类不被调用的时候,类的静态内部类是不会进行初始化的,这就避免了内存浪费问题;
  2. 当有方法调用 getInstance()方法时,会先初始化静态内部类,而静态内部类中的成员变量是 final 的,所以即便是多线程,其成员变量是不会被修改的,所以就解决了添加 synchronized 所带来的性能问题

首先感谢也恭喜大家能够看到这里,因为我想告诉你,上面所有的单例模式似乎还存在一点小问题 —— 暴力破坏。解决这一问题的方式就是下面提到的枚举类型单例。

至于缘由和为何枚举能够解决这个问题,同样,篇幅原因,我将在后面单独开一篇文章来说明。


下面我们先来讲讲注册式单例。

3、注册式(登记式)单例

注册式单例又称为登记式单例,就是将每一个实例都登记到某一个地方,使用唯一的标识获取实例。

注册式单例有两种写法:一种为容器缓存,一种为枚举登记。

先来看枚举式单例的写法。

枚举单例

废话少说,直接看代码,我们先创建EnumSingleton 类:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 下午3:42
  4. */
  5. public enum EnumSingleton {
  6. INSTANCE;
  7. private Object instance;
  8. EnumSingleton() {
  9. instance = new EnumResource();
  10. }
  11. public Object getInstance() {
  12. return instance;
  13. }
  14. }

来看测试代码:

  1. /**
  2. * @author eamon.zhang
  3. * @date 2019-09-30 下午3:47
  4. */
  5. public class EnumSingletonTest {
  6. @Test
  7. public void test() {
  8. try {
  9. ConcurrentExecutor.execute(() -> {
  10. EnumSingleton instance = EnumSingleton.INSTANCE;
  11. System.out.println(instance.getInstance());
  12. }, 10, 10);
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }

测试结果:

  1. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  2. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  3. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  4. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  5. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  6. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  7. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  8. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  9. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7
  10. com.eamon.javadesignpatterns.singleton.enums.EnumResource@3eadb1e7

结果都一样,说明枚举类单例是线程安全的,且是不可破坏的;在 JDK 枚举的语法特殊性,以及反射也为枚举保驾护航,让枚举式单例成为一种比较优雅的实现。

枚举类单例也是《Effective Java》中所建议使用的。

容器式单例

注册式单例还有另外一种写法,利用容器缓存,直接来看代码:

创建ContainerSingleton类:

  1. /**
  2. * @author EamonZzz
  3. * @date 2019-10-06 18:28
  4. */
  5. public class ContainerSingleton {
  6. private ContainerSingleton() {
  7. }
  8. private static Map<String, Object> ioc = new ConcurrentHashMap<String, Object>();
  9. public static Object getBean(String className) {
  10. synchronized (ioc) {
  11. if (!ioc.containsKey(className)) {
  12. Object object = null;
  13. try {
  14. object = Class.forName(className).newInstance();
  15. ioc.put(className, object);
  16. } catch (Exception e) {
  17. e.printStackTrace();
  18. }
  19. return object;
  20. } else {
  21. return ioc.get(className);
  22. }
  23. }
  24. }
  25. }

测试代码:

  1. @Test
  2. public void test() {
  3. try {
  4. ConcurrentExecutor.execute(() -> {
  5. Object bean = ContainerSingleton
  6. .getBean("com.eamon.javadesignpatterns.singleton.container.Resource");
  7. System.out.println(bean);
  8. }, 5, 5);
  9. } catch (Exception e) {
  10. e.printStackTrace();
  11. }
  12. }

测试结果:

  1. com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
  2. com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
  3. com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
  4. com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f
  5. com.eamon.javadesignpatterns.singleton.container.Resource@42e7420f

容器式写法适用于创建实例非常多的情况,便于管理。但是,是非线程安全的。

其实 Spring 中也有相关容器史丹利的实现代码,比如 AbstractAutowireCapableBeanFactory 接口

至此,注册式单例介绍完毕。


五、拓展

ThreadLocal 线程单例

ThreadLocal 不能保证其创建的对象是唯一的,但是能保证在单个线程中是唯一的,并且在单个线程中是天生的线程安全。

看代码:

  1. /**
  2. * @author EamonZzz
  3. * @date 2019-10-06 21:40
  4. */
  5. public class ThreadLocalSingleton {
  6. private ThreadLocalSingleton() {
  7. }
  8. private static final ThreadLocal<ThreadLocalSingleton> instance = ThreadLocal.withInitial(ThreadLocalSingleton::new);
  9. public static ThreadLocalSingleton getInstance() {
  10. return instance.get();
  11. }
  12. }

测试程序:

  1. @Test
  2. public void test() {
  3. System.out.println("-------------- 单线程 start ---------");
  4. System.out.println(ThreadLocalSingleton.getInstance());
  5. System.out.println(ThreadLocalSingleton.getInstance());
  6. System.out.println(ThreadLocalSingleton.getInstance());
  7. System.out.println(ThreadLocalSingleton.getInstance());
  8. System.out.println(ThreadLocalSingleton.getInstance());
  9. System.out.println("-------------- 单线程 end ---------");
  10. System.out.println("-------------- 多线程 start ---------");
  11. try {
  12. ConcurrentExecutor.execute(() -> {
  13. ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();
  14. System.out.println(Thread.currentThread().getName() + " : " + singleton);
  15. }, 5, 5);
  16. } catch (Exception e) {
  17. e.printStackTrace();
  18. }
  19. System.out.println("-------------- 多线程 end ---------");
  20. }

测试结果:

  1. -------------- 单线程 start ---------
  2. com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
  3. com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
  4. com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
  5. com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
  6. com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@1374fbda
  7. -------------- 单线程 end ---------
  8. -------------- 多线程 start ---------
  9. pool-1-thread-5 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@2f540d92
  10. pool-1-thread-1 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@3ef7ab4e
  11. pool-1-thread-2 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@604ffe2a
  12. pool-1-thread-3 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@50f41c9f
  13. pool-1-thread-4 : com.eamon.javadesignpatterns.singleton.threadlocal.ThreadLocalSingleton@40821a7a
  14. -------------- 多线程 end ---------

从测试结果来看,我们不难发现,在主线程中无论调用多少次,获得到的实例都是同一个;在多线程环境下,每个线程获取到了不同的实例。

所以,在单线程环境中,ThreadLocal 可以达到单例的目的。这实际上是以空间换时间来实现线程间隔离的。

六、总结

单例模式可以保证内存里只有一个实例,减少了内存的开销;可避免对资源的浪费。

单例模式看起来非常简单,实现起来也不难,但是在面试中却是一个高频的面试题。希望大家能够彻底理解。


本篇文章所涉及的源代码:

github.com/eamonzzz

原文链接:http://www.cnblogs.com/eamonzzz/p/11633482.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号