解析Spring中@Controller@Service等线程安全问题

我就是我 2023-10-15 15:08 6阅读 0赞

## 解析Spring中@Controller@Service等线程安全问题 ##

### 首先问@Controller @Service是不是线程安全的？ ###

答：默认配置下不是的。为啥呢？因为默认情况下`@Controller`没有加上`@Scope`，没有加`@Scope`就是默认值singleton，单例的。意思就是系统只会初始化一次Controller容器，所以每次请求的都是同一个Controller容器，当然是非线程安全的。举个栗子：

@RestController
    public class TestController {
        
    	private int var = 0;
    	@GetMapping(value = "/test_var")
    	public String test() {
        
    		System.out.println("普通变量var:" + (++var));
    		return "普通变量var:" + var ;
    	}
    }

在postman里面发三次请求，结果如下：

> 普通变量var:1  
> 普通变量var:2  
> 普通变量var:3

说明他不是线程安全的。怎么办呢？可以给他加上上面说的@Scope注解，如下：

@RestController
    @Scope(value = "prototype") // 加上@Scope注解，他有2个取值：单例-singleton 多实例-prototype
    public class TestController {
        
    	private int var = 0;
    	@GetMapping(value = "/test_var")
    	public String test() {
        
    		System.out.println("普通变量var:" + (++var));
    		return "普通变量var:" + var ;
    	}
    }

这样一来，每个请求都单独创建一个Controller容器，所以各个请求之间是线程安全的，三次请求结果：

> 普通变量var:1  
> 普通变量var:1  
> 普通变量var:1

加了@Scope注解多的实例prototype是不是一定就是线程安全的呢？

@RestController
    @Scope(value = "prototype") // 加上@Scope注解，他有2个取值：单例-singleton 多实例-prototype
    public class TestController {
        
    	private int var = 0;
    	private static int staticVar = 0;
    	@GetMapping(value = "/test_var")
    	public String test() {
        
    		System.out.println("普通变量var:" + (++var)+ "---静态变量staticVar:" + (++staticVar));
    		return "普通变量var:" + var + "静态变量staticVar:" + staticVar;
    	}
    }

看三次请求结果：

> 普通变量var:1—静态变量staticVar:1  
> 普通变量var:1—静态变量staticVar:2  
> 普通变量var:1—静态变量staticVar:3

虽然每次都是单独创建一个Controller但是扛不住他变量本身是static的呀，所以说呢，即便是加上@Scope注解也不一定能保证Controller 100%的线程安全。所以是否线程安全在于怎样去定义变量以及Controller的配置。所以来个全乎一点的实验，代码如下：

@RestController
    @Scope(value = "singleton") // prototype singleton
    public class TestController {
        
    	private int var = 0; // 定义一个普通变量
    	private static int staticVar = 0; // 定义一个静态变量
    	@Value("${test-int}")
    	private int testInt; // 从配置文件中读取变量
    	ThreadLocal<Integer> tl = new ThreadLocal<>(); // 用ThreadLocal来封装变量
    	@Autowired
    	private User user; // 注入一个对象来封装变量
    	@GetMapping(value = "/test_var")
    	public String test() {
        
    		tl.set(1);
    		System.out.println("先取一下user对象中的值："+user.getAge()+"===再取一下hashCode:"+user.hashCode());
    		user.setAge(1);
    		System.out.println("普通变量var:" + (++var) + "===静态变量staticVar:" + (++staticVar) + "===配置变量testInt:" + (++testInt)
    				+ "===ThreadLocal变量tl:" + tl.get()+"===注入变量user:" + user.getAge());
    		return "普通变量var:" + var + ",静态变量staticVar:" + staticVar + ",配置读取变量testInt:" + testInt + ",ThreadLocal变量tl:"
    				+ tl.get() + "注入变量user:" + user.getAge();
    	}
    }

补充Controller以外的代码：  
config里面自己定义的Bean:User

@Configuration
    public class MyConfig {
        
    	@Bean
    	public User user(){
        
    		return new User();
    	}
    }

我暂时能想到的定义变量的方法就这么多了，三次http请求结果如下：

先取一下user对象中的值：0===再取一下hashCode:241165852
    普通变量var:1===静态变量staticVar:1===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：1===再取一下hashCode:241165852
    普通变量var:2===静态变量staticVar:2===配置变量testInt:2===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：1===再取一下hashCode:241165852
    普通变量var:3===静态变量staticVar:3===配置变量testInt:3===ThreadLocal变量tl:1===注入变量user:1

可以看到，在单例模式下Controller中只有用ThreadLocal封装的变量是线程安全的。为什么这样说呢？我们可以看到3次请求结果里面只有ThreadLocal变量值每次都是从0+1=1的，其他的几个都是累加的，而user对象呢，默认值是0，第二交取值的时候就已经是1了，关键他的hashCode是一样的，说明每次请求调用的都是同一个user对象。  
下面将TestController 上的@Scope注解的属性改一下改成多实例的：`@Scope(value = "prototype")`，其他都不变，再次请求，结果如下：

先取一下user对象中的值：0===再取一下hashCode:853315860
    普通变量var:1===静态变量staticVar:1===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：1===再取一下hashCode:853315860
    普通变量var:1===静态变量staticVar:2===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：1===再取一下hashCode:853315860
    普通变量var:1===静态变量staticVar:3===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1

分析这个结果发现，多实例模式下普通变量，取配置的变量还有ThreadLocal变量都是线程安全的，而静态变量和user（看他的hashCode都是一样的）对象中的变量都是非线程安全的。也就是说尽管TestController 是每次请求的时候都初始化了一个对象，但是静态变量始终是只有一份的，而且这个注入的user对象也是只有一份的。静态变量只有一份这是当然的咯，那么有没有办法让user对象可以每次都new一个新的呢？当然可以：

public class MyConfig {
        
    	@Bean
    	@Scope(value = "prototype")
    	public User user(){
        
    		return new User();
    	}	
    }

在config里面给这个注入的Bean加上一个相同的注解`@Scope(value = "prototype")`就可以了，再来请求一下看看：

先取一下user对象中的值：0===再取一下hashCode:1612967699
    普通变量var:1===静态变量staticVar:1===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：0===再取一下hashCode:985418837
    普通变量var:1===静态变量staticVar:2===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1
    先取一下user对象中的值：0===再取一下hashCode:1958952789
    普通变量var:1===静态变量staticVar:3===配置变量testInt:1===ThreadLocal变量tl:1===注入变量user:1

可以看到每次请求的user对象的hashCode都不是一样的，每次赋值前取user中的变量值也都是默认值0。

### 总结： ###

在@Controller/@Service等容器中，默认情况下，scope值是单例-singleton的，也是线程不安全的。

尽量不要在@Controller/@Service等容器中定义静态变量，不论是单例(singleton)还是多实例(prototype)他都是线程不安全的。

默认注入的Bean对象，在不设置scope的时候他也是线程不安全的。

一定要定义变量的话，用ThreadLocal来封装，这个是线程安全的。

--------------------

## Spring单例模式下的并发保证 ##

1、spring框架controller和service默认都是单例的，那么多并发时，是如何实现线程安全的？

A、每当启用一个线程时，JVM就为他分配一个Java栈，栈是以帧为单位保存当前线程的运行状态。某个线程正在执行的方法称为当前方法，当前方法使用的栈帧称为当前帧，当前方法所属的类称为当前类，当前类的常量称为当前常量池。当线程执行一个方法时，它会跟踪当前常量池。

B、每当线程调用一个Java方法时，JVM就会在该线程对应的栈中压入一个帧，这个帧自然就成了当前帧。当执行这个方法时，它使用这个帧来存储参数、局部变量、中间运算结果等等。

C、Java栈上的所有数据都是私有的。任何线程都不能访问另一个线程的栈数据。所以我们不用考虑多线程情况下栈数据访问同步的情况。

D、如上，则@Controller是单例模式，即一个对象只有一个实例。通过线程副本\[栈\]的模式实现并发访问

2、线程副本与安全问题 线程副本通过栈和帧实现线程隔离，达到并发访问的目的，那么有没有前提呢？

A、如上所述，局部变量和中间运算结果集参数是线程隔离==>安全的，但是成员变量则是会受到多线程调用影响的

B、那Controller里面的service都是成员变量，会受影响么？service也是单例，其主要用来实现方法调用，就会进入帧的切换从而转变为中间结果的问题，同理单例的service的成员变量和局部变量的线程隔离性同Controller。  
PS：Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态。  
TransactionSynchronizationManager对资源resources采用ThreadLocal保管，就是dao的SqlSession\[亦即getConnection\]的由来

C、对应的成员变量就被暴露在所有线程面前了，所以最好用ThreadLocal保护起来，实现线程安全。

--------------------

## Controller、Service等是单例的为什么成处理并发请求 ##

在实际项目中Controller、Service、Dao层的类都是单例的，那么在并发场景下如何保证每个请求之间数据的安全呢，重点就是在于JVM的堆内容。

1.  概述  
    了解使用单例范围创建的 Spring bean 如何在幕后工作以服务多个并发请求。此外，将了解 Java 如何将 bean 实例存储在内存中以及它如何处理对它们的并发访问。
2.  Spring Beans 和 Java 堆内存  
    Java 堆是应用程序中所有正在运行的线程都可以访问的全局共享内存。当 Spring 容器创建具有单例范围的 bean 时，该 bean 存储在堆中。这样，所有并发线程都能够指向同一个 bean 实例。
3.  如何处理并发请求  
    举个例子，看一个 Spring 应用程序，它有一个名为ProductService的单例 bean ：

![img][]

这个 bean 有一个方法getProductById()，它将产品数据返回给它的调用者。此外，此 bean 返回的数据在端点 */product/\{id\}上暴露给客户端。  
接下来，探索当同时调用/product/\{id\}时在运行时会发生什么。具体来说，第一个线程将调用端点/product/1*，第二个线程将调用\*/product/2\*。  
Spring 为每个请求创建一个不同的线程。正如下面的控制台输出中看到的，两个线程都使用相同的ProductService实例来返回产品数据：

![img][img 1]

Spring 可以在多个线程中使用同一个 bean 实例，首先是因为对于每个线程，Java 都会创建一个私有堆栈内存。堆栈内存负责存储线程执行期间方法内部使用的局部变量的状态。这样，Java 确保并行执行的线程不会覆盖彼此的变量。  
其次，由于ProductService bean 在堆级别没有设置任何限制或锁定，因此每个线程的程序计数器都能够指向堆内存中 bean 实例的相同引用。因此，两个线程可以同时执行getProdcutById()方法。

接下来，了解为什么单例 bean 无状态是至关重要的。  
**无状态类：类中没有状态信息，一般是无成员变量或成员变量的值是不变的。**

1.  无状态单例 Bean 与有状态单例 Bean  
    要了解为什么无状态单例 bean 很重要，看看使用有状态单例 bean 的副作用是什么。  
    假设将productName变量移至类级别（即成员变量）：

![img][img 2]

现在，再次运行服务并查看输出

![img][img 3]

对productId 1 的调用显示的是productName “Product 2”而不是“Product 1”。发生这种情况是因为ProductService是有状态的，并且与所有正在运行的线程共享相同的productName变量。

为了避免这样的不良副作用，保持单例 bean 无状态至关重要。

[img]: https://img-blog.csdnimg.cn/img_convert/9237b2710d0ea494cec2024651f59189.webp?x-oss-process=image/format,png
[img 1]: https://img-blog.csdnimg.cn/img_convert/d65a2af08393f09bc798ef4fc0f81c5e.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/20ac3c98ae6c219fae78bc668035f53e.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/a746516c7fb26b8f320166ec4e2ac9b1.png