浅析Spring IOC bean为什么默认是单例

 更新时间:2023年12月14日 09:57:17   作者:Lzfnemo2009  
单例的意思就是说在 Spring IoC 容器中只会存在一个 bean 的实例,无论一次调用还是多次调用,始终指向的都是同一个 bean 对象,本文小编将和大家一起分析Spring IOC bean为什么默认是单例,需要的朋友可以参考下

首先解释一下什么是单例 bean?

单例的意思就是说在 Spring IoC 容器中只会存在一个 bean 的实例,无论一次调用还是多次调用,始终指向的都是同一个 bean 对象

用代码来解释单例 bean

public class UserService {
    public void sayHello() {
        System.out.println("hello");
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 
		<!-- scope 属性就是用来设置 bean 的作用域的,不配置的话默认就是单例,这里显示配置了 singleton -->
    <bean id="userService" class="com.fyl.springboot.bean.singleton.UserService" scope="singleton"/>
 
</beans>
public class Demo {
 
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans-singleton.xml");
 
        UserService service = context.getBean(UserService.class);
        UserService service1 = context.getBean(UserService.class);
        System.out.println(service == service1);
    }
}

运行 main 方法最后会输出:true,这就很明显的说明了无论多少次调用 getBean 方法,最终得到的都是同一个实例。

把上面 xml 文件的配置修改一下,修改为:

<!-- scope 的值改为了 prototype,表示每次请求都会创建一个新的 bean -->
<bean id="userService" class="com.fyl.springboot.bean.singleton.UserService" scope="prototype"/>

然后再次运行 main 方法,结果输出:false,说明两次调用 getBean 方法,得到的不是同一个实例。

了解了什么是单例 bean 之后,我们继续来说说单例 bean 的线程安全问题

为什么会存在线程安全问题呢?

因为对于单实例来说,所有线程都共享同一个 bean 实例,自然就会发生资源的争抢。

用代码来说明线程不安全的现象

public class ThreadUnSafe {
 
    public int i;
 
    public void add() {
        i++;
    }
 
    public void sub() {
        i--;
    }
 
    public int getValue() {
        return i;
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 
    <bean id="threadUnSafe" class="com.fyl.springboot.bean.singleton.ThreadUnSafe" scope="singleton"/>
 
</beans>
public class Demo {
 
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans-singleton.xml");
 
        for (int j = 0; j < 10; j++) {
            new Thread(() -> {
                ThreadUnSafe service = context.getBean(ThreadUnSafe.class);
                for (int i = 0; i < 1000; i++) {
                    service.add();
                }
                for (int i = 0; i < 1000; i++) {
                    service.sub();
                }
                System.out.println(service.getValue());
            }).start();
        }
    }
}

上面的代码中,创建了 10 个线程来获取 ThreadUnSafe 实例,并且循环 1000 次加法,循环 1000 次减法,并把最后的结果打印出来。理想的情况是每个线程打印出来的结果都是 0

先看一下运行结果:

2073
1736
1080
1060
221
49
50
-231
-231
-231

从结果可以看出,运行结果都不是 0,这明显的是线程不安全啊!

为什么会出现这种情况?

因为 10 个线程获取的 ThreadUnSafe 实例都是同一个,并且 10 个线程都对同一个资源 i 发生了争抢,所以才会导致线程安全问题的发生。

现在把 xml 文件中的配置做一下更改:scope 的值改为 prototype

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 
    <!-- scope 的值改为 prototype -->
    <bean id="threadUnSafe" class="com.fyl.springboot.bean.singleton.ThreadUnSafe" scope="prototype"/>
 
</beans>

然后再次运行 main 方法,发现无论运行多少次,最后的结果都是 0,是线程安全的!

因为 prototype 作用域下,每次获取的 ThreadUnSafe 实例都不是同一个,所以自然不会有线程安全的问题。

如果单例 bean 是一个无状态的 bean,还会有线程安全问题吗?

不会,无状态 bean 没有实例对象,不能保存数据,是不变类,是线程安全的。

public class ThreadSafe {
 
    public void getValue() {
        int val = 0;
        for (int i = 0; i < 1000; i++) {
            val++;
        }
        for (int i = 0; i < 1000; i++) {
            val--;
        }
        System.out.println(val);
    }
}
public class Demo {
 
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans-singleton.xml");
 
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                ThreadSafe service = context.getBean(ThreadSafe.class);
                service.getValue();
            }).start();
        }
    }
}
 

运行结果为 0

事实证明,无状态的 bean 是线程安全的。(无状态 bean 应该是这个意思,如有不对的地方,还望指出)

那么针对单例 bean,而且是有状态的 bean,应该如何保证线程安全呢?

那有人肯定会说了:既然是线程安全问题,那就加锁呗!

毫无疑问加锁确实可以,但是加锁多多少少有点性能上的下降

加锁代码如下所示:

public class Demo {
 
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans-singleton.xml");
 
        for (int j = 0; j < 10; j++) {
            new Thread(() -> {
                ThreadUnSafe service = context.getBean(ThreadUnSafe.class);
                synchronized (service) {
                    for (int i = 0; i < 1000; i++) {
                        service.add();
                    }
                    for (int i = 0; i < 1000; i++) {
                        service.sub();
                    }
                    System.out.println(service.getValue());
                }
            }).start();
        }
    }
}

还有一种方法是使用 ThreadLocal

ThreadLocal 简单的说就是在自己线程内创建一个变量的副本,那么线程操作的自然也就是自己线程内的资源了,也就规避了线程安全问题。但是却带来了空间上的开销。

使用方法如下:

public class ThreadUnSafe {
 
    ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
 
    public void add() {
        Integer i = threadLocal.get();
        if (i == null) {
            i = 0;
        }
        i++;
        threadLocal.set(i);
    }
 
    public void sub() {
        Integer i = threadLocal.get();
        i--;
        threadLocal.set(i);
    }
 
    public Integer getValue() {
        return threadLocal.get();
    }
}
public class Demo {
 
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans-singleton.xml");
 
        for (int j = 0; j < 10; j++) {
            new Thread(() -> {
                ThreadUnSafe service = context.getBean(ThreadUnSafe.class);
                for (int i = 0; i < 1000; i++) {
                    service.add();
                }
                for (int i = 0; i < 1000; i++) {
                    service.sub();
                }
                System.out.println(service.getValue());
            }).start();
        }
    }
}

使用 ThreadLocal 即使不加锁也保证了输出的结果都是 0

加锁和使用 ThreadLocal 各有各的特点

  • 加锁是以时间换空间
  • ThreadLocal 是以空间换时间

以上就是浅析Spring IOC bean为什么默认是单例的详细内容,更多关于Spring IOC bean默认单例的资料请关注脚本之家其它相关文章!

相关文章

  • eclipse如何搭建Springboot项目详解

    eclipse如何搭建Springboot项目详解

    今天带大家学习eclipse如何搭建Spring boot项目,文中有非常详细的图文解说,对正在学习java的小伙伴们有很好地帮助,需要的朋友可以参考下
    2021-05-05
  • SpringBoot与docker的结合的示例

    SpringBoot与docker的结合的示例

    本篇文章主要介绍了SpringBoot与docker的结合的示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-03-03
  • AsyncConfigurerSupport自定义异步线程池处理异常

    AsyncConfigurerSupport自定义异步线程池处理异常

    这篇文章主要为大家介绍了AsyncConfigurerSupport自定义异步线程池处理异常详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-06-06
  • MyBatis如何调用存储过程

    MyBatis如何调用存储过程

    这篇文章主要介绍了MyBatis如何调用存储过程问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-05-05
  • 如何解决Eclipse找不到或无法加载主类问题

    如何解决Eclipse找不到或无法加载主类问题

    这篇文章主要介绍了如何解决Eclipse找不到或无法加载主类问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-06-06
  • 使用Mybatis实现分页效果示例

    使用Mybatis实现分页效果示例

    大家好,本篇文章主要讲的是使用Mybatis实现分页效果示例,感兴趣的同学赶快来看一看吧,对你有帮助的话记得收藏一下,方便下次浏览
    2021-12-12
  • 简单分析Java线程编程中ThreadLocal类的使用

    简单分析Java线程编程中ThreadLocal类的使用

    这篇文章主要介绍了Java线程编程中ThreadLocal类的使用,包括使用其对共享变量的操作的分析,需要的朋友可以参考下
    2015-12-12
  • 详解spring项目中如何动态刷新bean

    详解spring项目中如何动态刷新bean

    这篇文章主要为大家介绍了详解spring项目中如何动态刷新bean,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-08-08
  • java 一键部署 jar 包和 war 包

    java 一键部署 jar 包和 war 包

    这篇文章主要介绍了Java创建打包命令、创建启动文件等功能实现Java一键部署 jar 包和 war 包,感兴趣的下伙伴可以参考下文
    2021-09-09
  • Java集合类知识点总结

    Java集合类知识点总结

    本文把Java集合类的相关知识点做了总结,并把Java常用集合类之间的区别做了分析,一起参考学习下。
    2018-02-02

最新评论