精通有状态vs无状态(Stateful vs Stateless)—Immutable模式之姐妹篇

我相信有不少人还不明白有状态和无状态(Stateful and Stateless)的概念，那么我们今天就来谈谈有状态和无状态，一方面不断总结提高自我，另一方面兼扫盲。这是Immutable不变模式的姐妹篇，大家可以参照着读。
Immutable不变模式的分析blog: http://www.iteye.com/topic/959751

基本概念：

有状态就是有数据存储功能。有状态对象(Stateful Bean)，就是有实例变量的对象，可以保存数据，是非线程安全的。在不同方法调用间不保留任何状态。

无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象.不能保存数据，是不变类，是线程安全的。

代码更好理解：

/**
 * 有状态bean,有state,user等属性，并且user有存偖功能，是可变的。
 * 
 * @author Peter Wei
 * 
 */
public class StatefulBean {

	public int state;
	// 由于多线程环境下，user是引用对象，是非线程安全的
	public User user;

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}
}

/**
 * 无状态bean,不能存偖数据。因为没有任何属性，所以是不可变的。只有一系统的方法操作。
 * 
 * @author Peter Wei
 * 
 */
public class StatelessBeanService {

	// 虽然有billDao属性，但billDao是没有状态信息的，是Stateless Bean.
	BillDao billDao;

	public BillDao getBillDao() {
		return billDao;
	}

	public void setBillDao(BillDao billDao) {
		this.billDao = billDao;
	}

	public List<User> findUser(String Id) {
return null;
	}
}

单例模式中的有状态和无状态:
单例类可以是有状态的（stateful），一个有状态的单例对象一般也是可变（mutable）单例对象。有状态的可变的单例对象常常当做状态库（repositary）使用。比如一个单例对象TaskCache（Spring中配为singleton）可以持有一个AtomicLong类型的属性，用来给一个系统提供一个数值惟一的序列号码，作为任务通迅管理的ID生成器。同时，一个单例类也可以持有一个聚集，从而允许存储多个状态，如示例中的ExpiringMap缓存任务列表。
代码示例：

import java.util.concurrent.atomic.AtomicLong;

import org.apache.mina.util.ExpiringMap;

/**
 * Description: 内存中缓存的实时控制端任务列表.示例有状态的单例类
 * 
 * @author Peter Wei
 * @version 1.0 Dec 2, 2008
 */
public class TaskCache {

	// 请求超时
	private short requestTimeout;

	// 这个缓存Map是线程安全,并且有定时超时功能
	private ExpiringMap<String, Object> tasksMap = new ExpiringMap<String, Object>();

	// 线程安全的原子类,示例有状态的单例类
	private static AtomicLong seqNo = new AtomicLong(1);

	// 示例有状态的单例类
	public Long nextSeqNo() {
		return seqNo.getAndIncrement();
	}

	public void setRequestTimeout(short requestTimeout) {
		this.requestTimeout = requestTimeout;
	}

	// 启动过期检测
	public void startExpiring() {
		tasksMap.getExpirer().setTimeToLive(requestTimeout);
		tasksMap.getExpirer().startExpiringIfNotStarted();
	}

	// 停止过期检测
	public void stopExpiring() {
		tasksMap.getExpirer().stopExpiring();
	}

	// 取任务列表.
	public Object getTasks(String key) {
		return tasksMap.get(key);
	}

	// 去除任务列表.
	public Object removeTasks(String key) {
		return tasksMap.remove(key);
	}

	// 添加任务列表.
	public void addTasks(String key, Object value) {
		tasksMap.put(key, value);
	}
}

单例类也可以是没有状态的（stateless），仅用做提供工具性函数的对象。既然是为了提供工具性函数，也就没有必要创建多个实例，因此使用单例模式很合适。平常的单例类都是没有状态的，这里就不示例了。一个没有状态的单例类也就是不变（Immutable）单例类。关于不变模式，请参考 http://www.iteye.com/topic/959751

EJB中的有状态与无状态：

1.Stateful session bean的每个用户都有自己的一个实例，所以两者对stateful session bean的操作不会影响对方。另外注意：如果后面需要操作某个用户的实例，你必须在客户端缓存Bean的Stub对象（JSP通常的做法是用Session缓存），这样在后面每次调用中，容器才知道要提供相同的bean实例。

2.Stateless Session Bean不负责记录使用者状态，Stateless Session Bean一旦实例化就被加进会话池中，各个用户都可以共用。如果它有自己的属性（变量），那么这些变量就会受到所有调用它的用户的影响。

3.从内存方面来看，Stateful Session Bean与Stateless Session Bean比较，Stateful Session Bean会消耗J2EE Server 较多的内存，然而Stateful Session Bean的优势却在于他可以维持使用者的状态。

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作用域。

Servlet、Struts中的有状态和无状态:

1.Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web 容器负责的。一个Servlet类在Application中只有一个实例存在，也就是有多个线程在使用这个实例。这是单例模式的应用。无状态的单例是线程安全的，但我们如果在Servlet里用了实例变量，那么就变成有状态了，是非线程安全的。如下面的用法就是不安全的,因为user,out都是有状态信息的。

/**
 * 非线程安全的Servlet。
 * @author Peter Wei
 *
 */
public class UnSafeServlet HttpServlet{
	
	User user;
	PrintWriter out;
	
	public void doGet (HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException{
		//do something...
	}
}

Out,Request,Response,Session,Config,Page,PageContext是线程安全的,Application在整个系统内被使用,所以不是线程安全的.

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

/**
 * 非线程安全的Struts1示例
 * 
 * @author Peter Wei
 * 
 */
public class UnSafeAction1 extends Action {

	// 因为Struts1是单例实现，有状态情况下，对象引用是非线程安全的
	User user;

	public void execute() {
		// do something...
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}
}  

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

4.如何解决Servlet和Struts1的线程安全问题，当我们能比较好的理解有状态和无状态的原理，自然很容易得出结论：不要使用有状态的bean,也就是不要用实例变量。如果用，就要用prototype模式。Struts1 user guide里有： Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables , in your Action class.

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

国外一些哥们的观点：
Immutable objects may not be altered after their creation. So: Yes, they are some kind of stateless.As immutable objects can not be changed, there is no need for locking - reading access to objects is always threadsafe (when not modifying variables). Therefore, real immutable objects are always threadsafe.

Rod Johnson大叔的观点：
Stateless or Stateful?
Service objects will usually be stateless. Stateless service layers are highly scalable: They pose no replication issues and there is no need to allocate additional resources for every client. (Remember that one of
the key motivations of a middle tier is to share resources between multiple clients.) It is also much easier for stateless service layers to support remote clients, if necessary. A stateless service layer is one concession of object orientation that I find not too painful.
此处省去N个字。
If possible, design applications to use a stateless service layer. Hold state in the web tier, rather than in the business logic tier, if possible.

关于不变模式分析，请参考 http://www.iteye.com/topic/959751

评论

24 楼 richard_2010 2011-03-17  

我认为lz讲得更模糊，而且有些概念混淆了

23 楼 peterwei 2011-03-16  

beforezero 写道

我对stateful session bean 一直有点疑惑，就是stateful保持的状态的生存周期是多久？ 购物车的例子更让我迷惑。

就拿这个例子来说
ShoppingCartBean :
            List<Product> products
            addItem();
            browse();

我一次addItem，然后browse。这里有两次客服端request。我通过jndi拿到的ShoppingCartBean是否是同一个呢，也就是bean的状态products是request级别还是session级别？

引开来说stateful session bean针对的是一个线程还是用户的会话？

其实我这篇文章，并不是主要介绍ejb的。 .你说了，就说说。
总体周期是从客户端调用create()到客户端调用remove()，当然会话也有超时，当客户端一段时间没有访问SFSB方法时，EJB容器会将其回收。 SFSB的状态是指其实例变量的值，EJB容器分配一个SFSB实例给客户端使用后将保持该实例只给该客户端使用。

其实，你可以将SFSB的状态理解成HTTP的Session状态。

关于有状态会话BEAN的生命周期：
1:不存在状态---(client调用create())(容器调用Class.newInstance(),setSessionContext(),ejbCreate())---> 进入方法就绪状态(此时可以为client服务)
---> 如果超时则容器将其销毁，回到不存在状态。
---> 如果服务器要节省资源或遇到新事务开启，则释放资源，实例打回到不存在状态。
序列化实例字段。(容器调用ejbPassivate()挂起)---> 事务等结束，重新找会资源，反序列化实例字段。
建立一个新的BEAN实例(容器调用ejbActivate()激活---> 容器调用ejbRemove()或客户显示调用remove()也会将BEAN打回到不存在状态。

22 楼 beforezero 2011-03-16  

我对stateful session bean 一直有点疑惑，就是stateful保持的状态的生存周期是多久？ 购物车的例子更让我迷惑。

就拿这个例子来说
ShoppingCartBean :
            List<Product> products
            addItem();
            browse();

我一次addItem，然后browse。这里有两次客服端request。我通过jndi拿到的ShoppingCartBean是否是同一个呢，也就是bean的状态products是request级别还是session级别？

引开来说stateful session bean针对的是一个线程还是用户的会话？

21 楼 peterwei 2011-03-15  

piao_bo_yi 写道

  你写的类StatefulBean并不是线程不安全的。什么叫线程安全？指的就是不同线程不存在同时访问一个变量，或一个函数的情形。什么样的变量能被多个线程访问呢？JAVA中，类中的静态变量，单例类的任何属性都可以被多个线程访问。所以线程安全与否必须和这些在一起谈才有意义吧？不然，你可以把任何普通类的对象说成是线程不安全的。
另外，不变的对象不代表是线程安全的。不允许重入的函数，如果两个线程同时访问，一个异步的指针移动程序必然崩溃。

可能你没有仔细看。:->我没说StatefulBean是线程安全的。强不变类就是代表线程安全的，因为不可变，可以看看不变模式中的强不变。

20 楼 piao_bo_yi 2011-03-15  

  你写的类StatefulBean并不是线程不安全的。什么叫线程安全？指的就是不同线程不存在同时访问一个变量，或一个函数的情形。什么样的变量能被多个线程访问呢？JAVA中，类中的静态变量，单例类的任何属性都可以被多个线程访问。所以线程安全与否必须和这些在一起谈才有意义吧？不然，你可以把任何普通类的对象说成是线程不安全的。
另外，不变的对象不代表是线程安全的。不允许重入的函数，如果两个线程同时访问，一个异步的指针移动程序必然崩溃。
  有一些类的方法本来不用属性，却没有声明为static，主要是为了利用多态。所以工具类（纯静态方法），和这种类还是区别开来比较好。

19 楼 peterwei 2011-03-15  

piao_bo_yi 写道

peterwei 写道

piao_bo_yi 写道

LZ是不是弄混了单例模式？是不是弄混了线程安全与否的概念？而且，状态不就是一个对象的值么？

单例模式与线程安全与否哪里混淆了?你可以说说看。我认为还是你没有认真看，或者说理解得不够深刻。

我又仔细看了下，你说的那些singleton, prototype都是指用Spring负责管理的啊，我把那些和设计模式中的传统意义搞混了。还有线程安全与否，你都是指用Spring来管理对象生成的前提下讨论的。我对SPRING不熟，所以才会误解。把标题改成Spring下的XXX似乎更好。

spring和传统设计模式里的单例是一样的。我说的singeton,protyotye同样适用于不用spring的环境。

18 楼 chenyongxin 2011-03-15  

如果楼主能够从内存的角度说说就更好了，方法区，堆，栈了解了，有状态和无状态就没有这样蹩脚了

17 楼 piao_bo_yi 2011-03-15  

peterwei 写道

piao_bo_yi 写道

LZ是不是弄混了单例模式？是不是弄混了线程安全与否的概念？而且，状态不就是一个对象的值么？

单例模式与线程安全与否哪里混淆了?你可以说说看。我认为还是你没有认真看，或者说理解得不够深刻。

我又仔细看了下，你说的那些singleton, prototype都是指用Spring负责管理的啊，我把那些和设计模式中的传统意义搞混了。还有线程安全与否，你都是指用Spring来管理对象生成的前提下讨论的。我对SPRING不熟，所以才会误解。把标题改成Spring下的XXX似乎更好。

16 楼 月落码农 2011-03-14  

peterwei 写道

月落码农 写道

不变类也是有状态的，只不过他的状态构建好之后，就不能改变，所以是线程安全的，而不是说不变类是无状态的！这一点我无法认同你的观点！请将无状态类和不变类这两个概念分开。

你是对的。我并没有说不变类就是没有状态的。我是说无状态类是不变类。都没有状态怎么可能变。

引用

无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象.不能保存数据，是不变类，是线程安全的。

我原话是这样的。

不好意思，我前面看错了，对不起哇

15 楼 ymkyve 2011-03-14  

把状态和线程安全结合起来讲,大家应该更好理解些

14 楼 peterwei 2011-03-14  

月落码农 写道

不变类也是有状态的，只不过他的状态构建好之后，就不能改变，所以是线程安全的，而不是说不变类是无状态的！这一点我无法认同你的观点！请将无状态类和不变类这两个概念分开。

你是对的。我并没有说不变类就是没有状态的。我是说无状态类是不变类。都没有状态怎么可能变。

引用

无状态就是一次操作，不能保存数据。无状态对象(Stateless Bean)，就是没有实例变量的对象.不能保存数据，是不变类，是线程安全的。

我原话是这样的。

13 楼 月落码农 2011-03-14  

不变类也是有状态的，只不过他的状态构建好之后，就不能改变，所以是线程安全的，而不是说不变类是无状态的！这一点我无法认同你的观点！请将无状态类和不变类这两个概念分开。

12 楼 peterwei 2011-03-14  

asklxf 写道

有状态和无状态与线程安全是两个概念

首先有状态也可以是线程安全的，你可以加锁，也可以以只读模式访问，例如：

class StatelessBean {

  Properties props;

  public StatelessBean() {
    initProps();
  }
}

因为有成员变量props，所有该Bean从编程角度说是有状态的，但是你只在构造方法中初始化他，然后其他方法均不修改，这样就是线程安全的。从业务角度说，这个Bean是无状态的，因为他的状态不变，不管几个客户端访问，也无论是否并发访问

从编程模型说spring里的bean都是可变的，通常也都是有状态的，但是，只要从业务上保证是无状态的，就可以简单做服务器叠加。单机下就可以用多进程模拟。

其实正确的目标是追求无状态的服务，只要牢记永远不要使用Servlet的Session，这样从大方向上说就变成无状态了

恩，你说的是对的。我并没有把有状态和无状态与线程安全是两个概念等同起来。有状态当然可以是线程安全的，请看我例子中的有状态的单例TaskCache,里面的ExpiredMap,AtomicLong就是属性，也就是有状态。但那两个东东都是基于线程安全实现的。

引用

因为有成员变量props，所有该Bean从编程角度说是有状态的，但是你只在构造方法中初始化他，然后其他方法均不修改，这样就是线程安全的。从业务角度说，这个Bean是无状态的，因为他的状态不变，不管几个客户端访问，也无论是否并发访问

事实并不是这样的，如果说只在构造方法中初始化他，然后其他方法均不修改,那么他只是弱不变模式。props是引用对象的话，其它线程依然可以修改它的状态。请看我另一篇blog,不变模式分析中的例子。

11 楼 asklxf 2011-03-14  

有状态和无状态与线程安全是两个概念

首先有状态也可以是线程安全的，你可以加锁，也可以以只读模式访问，例如：

class StatelessBean {

  Properties props;

  public StatelessBean() {
    initProps();
  }
}

因为有成员变量props，所有该Bean从编程角度说是有状态的，但是你只在构造方法中初始化他，然后其他方法均不修改，这样就是线程安全的。从业务角度说，这个Bean是无状态的，因为他的状态不变，不管几个客户端访问，也无论是否并发访问

从编程模型说spring里的bean都是可变的，通常也都是有状态的，但是，只要从业务上保证是无状态的，就可以简单做服务器叠加。单机下就可以用多进程模拟。

其实正确的目标是追求无状态的服务，只要牢记永远不要使用Servlet的Session，这样从大方向上说就变成无状态了

10 楼 peterwei 2011-03-14  

oojdon 写道

比较浅显，要是结合用例，用户状态，应用事务，Restful,集群分布式，Seam对话模式等切入点来讲解有状态和无状态就好了。

这个要求太高了吧，哈哈。把这些都说完，也差不多可以写半本书了。我相信还是有很多人对这两个概念根本不懂，算是总结兼扫盲吧。

9 楼 oojdon 2011-03-14  

比较浅显，要是结合用例，用户状态，应用事务，Restful,集群分布式，Seam对话模式等切入点来讲解有状态和无状态就好了。

8 楼 peterwei 2011-03-14  

scvptz 写道

基本概念里面的例子，StatelessBeanService有问题吧
就算BillDao不带任何属性，但它本身就是一个状态啊
比如可以有多个BillDao的实例，每个实例就是一个不同的状态

严格意义上说，它算有一个状态。但是这样的状态不存偖信息的，在实例中dao也只是一些find,add,save的方法。而且dao本身也是单例的，不存在线程安全问题。dao不像Action中的User那样。所以可以说这个service是无状态的。

7 楼 scvptz 2011-03-14  

基本概念里面的例子，StatelessBeanService有问题吧
就算BillDao不带任何属性，但它本身就是一个状态啊
比如可以有多个BillDao的实例，每个实例就是一个不同的状态

6 楼 peterwei 2011-03-14  

piao_bo_yi 写道

LZ是不是弄混了单例模式？是不是弄混了线程安全与否的概念？而且，状态不就是一个对象的值么？

单例模式与线程安全与否哪里混淆了?你可以说说看。我认为还是你没有认真看，或者说理解得不够深刻。

5 楼 kissroom112 2011-03-14  

很不错 拨云见日