线程安全，有状态，无状态的对象

港控/mmm° 2022-08-04 10:46 210阅读 0赞

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.  
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.  
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。  
进程有独立的地址空间  
  
  
进程有单独的地址空间，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。  
文本区域存储处理器执行的代码；  
数据区域存储变量和进程执行期间使用的动态分配的内存；  
堆栈区域存储着活动过程调用的指令和本地变量。  
  
  
线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间  
一个线程包含以下内容。  
  
•一个指向当前被执行指令的指令指针；  
•一个栈；  
•一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值；  
•一个私有的数据区。  
  
**线程安全**   
  
    如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 　　或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

线程安全问题都是由全局变量及静态变量引起的。    
    若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

**关于线程安全：**

1） 常量始终是线程安全的，因为只存在读操作。

2）每次调用方法前都新建一个实例是线程安全的，因为不会访问共享的资源。

3）局部变量是线程安全的。因为每执行一个方法，都会在独立的空间创建局部变量，它不是共享的资源。局部变量包括方法的参数变量和方法内变量。   
  
  
**有状态和无状态对象**  
  
有状态就是有数据存储功能。有状态对象(Stateful Bean)，就是有实例变量的对象  ，可以保存数据，是非线程安全的。在不同方法调用间不保留任何状态。  
  
无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象  .不能保存数据，是不变类，是线程安全的。

有状态对象:

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.   **public**   **class**  StatefulBean \{     
2.       
3.       **public**   **int**  state;     
4.     
5.       **public**   **int**  getState() \{     
6.           **return**  state;     
7.      \}     
8.      
9.       **public**   **void**  setState( **int**  state) \{     
10.          **this** .state = state;     
11.     \}     
12.     
13.      **public**  User getUser() \{     
14.          **return**  user;     
15.     \}     
16.     
17.      **public**   **void**  setUser(User user) \{     
18.          **this** .user = user;     
19.    \}     
20. \}

无状态对象

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  **public**   **class**  StatefulBean \{     
2.      
3.     // 虽然有userDao 属性，但userDao 是没有状态信息的，是Stateless Bean。  
4.      **public**   UserDao  userDao  ;     
5.    
6.      **public**   **int**  getState() \{     
7.          **return**  state;     
8.     \}     
9.     
10.     **public**   **void**  setState( **int**  state) \{     
11.         **this** .state = state;     
12.    \}     
13.    
14.     **public**  User getUser() \{     
15.         **return**  user;     
16.    \}     
17.    
18.     **public**   **void**  setUser(User user) \{     
19.         **this** .user = user;     
20.   \}     
21.

单例类可以是有状态的（stateful），也可以是无状态的。无状态的单例模式，是线程安全的。有状态的单例模式，是非线程安全的。

**Spring中的有状态(Stateful)和无状态(Stateless)  **** **  
  
1.通过上面的分析，相信大家已经对有状态和无状态有了一定的理解。无状态的Bean适合用不变模式，技术就是单例模式，这样可以共享实例，提高性能。有状态的Bean，多线程环境下不安全，那么适合用Prototype原型模式。Prototype: 每次对bean的请求都会创建一个新的bean实例。  
  
2.默认情况下，从Spring bean工厂所取得的实例为singleton（scope属性为singleton）,容器只存在一个共享的bean实例。  
  
3.理解了两者的关系，那么scope选择的原则就很容易了：有状态的bean都使用prototype作用域，而对无状态的bean则应该使用singleton作用域。  
  
4.如Service层、Dao层用默认singleton就行，虽然Service类也有dao这样的属性，但dao这些类都是没有状态信息的，也就是 相当于不变(immutable)类，所以不影响。Struts2中的Action因为会有User、BizEntity这样的实例对象，是有状态信息 的，在多线程环境下是不安全的，所以Struts2默认的实现是Prototype模式。在Spring中，Struts2的Action中，scope 要配成prototype作用域。

**Struts中的线程安全**

1.Struts1也是基于单例模式实现，也就是只有一个Action实例供多线程使用。默认的模式是前台页面数据通过actionForm传入，在 action中的excute方法接收，这样action是无状态的，所以一般情况下Strunts1是线程安全的。如果Action中用了实例变量，那 么就变成有状态了，同样是非线程安全的。

2.Struts2默认的实现是Prototype模式。也就是每个请求都新生成一个Action实例，所以不存在线程安全问题。需要注意的是，如果由Spring管理action的生命周期， scope要配成prototype作用域。

**总结：  **** **  
Stateless无状态用单例Singleton模式，Stateful有状态就用原型Prototype模式。    
Stateful 有状态是多线程编码的天敌，所以在开发中尽量用Stateless无状态，无状态是不变(immutable)模式的应用，有很多优点：不用管线程和同步的问题  ，如果值是不可变的，程序不用担心多个线程改变共享状态，所以可以避免线程竞争的bugs. 因为没有竞争，就不用用locks等机制，所以无状态的不变机制，也可以避免产生死锁现象。

原文出处:

[/images/20220731/22721fbda4864153a1ff63a2c215a489.png][icon_star.png 1]

[http://blog.csdn.net/showwair/article/details/7672443][icon_star.png 1]

[icon_star.png]: http://zhuyuehua.iteye.com/images/icon_star.png
[icon_star.png 1]: /images/20220731/22721fbda4864153a1ff63a2c215a489.png