http://blog.csdn.net/showwair/article/details/7672443
基本概念:
有状态就是有数据存储功能。有状态对象(Stateful Bean),就是有实例变量的对象 ,可以保存数据,是非线程安全的。在不同方法调用间不保留任何状态。
无状态就是一次操作,不能保存数据。无状态对象(Stateless Bean),就是没有实例变量的对象 .不能保存数据,是不变类,是线程安全的。
代码更好理解:
- 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;
- }
- }
- 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;
- 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.javaeye.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都是有状态 信息的。
- 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中用了实例变量,那 么就变成有状态了,同样是非线程安全的。像下面这样就是线程不安全的。
- 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.
相关推荐
面向对象及练习题 面向对象 1.1面向对象概念 面向对象是一种编程思想,是对现实世界中的事物进行抽象的方式。应用到代码 编程设计中,是一种建立现实世界事物模型的方式。 1.2 面向对象和面向过程区别 面向过程关注...
面向对象及练习题 面向对象 面向对象概念 面向对象是一种编程思想,是对现实世界中的事物进行抽象的方式。应用到代码 编程设计中,是一种建立现实世界事物模型的方式。 面向对象和面向过程区别 面向过程关注的是完成...
简介状态模式的核心是封装, 状态的变更引起了行为的变更, 从外部看起来就好像这个对象对应的类发生了改变一样。解决什么问题?存在状态概念,程序需要根据状态去切换相
( 1)对象属性:属性用来表示对象的状态。 ( 2)对象方法:对象方法是描述对象行为的过程。 2.类 类是对一类相似对象的性质描述,这些对象具有相同种类的属性以及 方法 3.子类与继承 在面向对象的方法里, 继承是指...
5.8 对象类的高级概念 5.8.1 抽象类 5.8.2 参数对象类 5.8.3 型与实现对象类 5.8.4 导出属性与导出关联 5. 9 对象类图的应用 5.9.1 对象类图的建立 5.9.2 模型景象与粒度控制 5.9.3 数据库...
所谓对象就是真实世界中的实体,对象与实体是一一对应的,也就是说现实世界中每一个实体都是一个对象,它是一种具体的概念。对象有以下特点: 对象具有属性和行为。 对象具有变化的状态。 对象具有唯一性。 对象都是...
Kubernetes中的大部分概念Node、Pod、Replication Controller、Service等都可以看作一种“资源对象”,几 乎所有的资源对象都可以通过kubectl工具(API调用)执行增、删、改、查等操作并将其保存在etcd中持久化 存储...
Laravel中任何对象的状态模式 该软件包为Laravel中的非口才对象添加了状态支持。 如果您需要Eloquent模型的支持,则有许多不错的选择: :warning: 此软件包的较小发行版可能尚未引起稳定的发行,因此可能会导致重大...
OOAD 面向对象程序设计课件 1_绪论.ppt 2_面向对象的分析技术.ppt 3_UML用例图(Use Case).ppt 4_UML类图.ppt 5_UML交互图、状态图、包图.ppt ...12_面向对象概念的编程实现.ppt 13_设计模式.ppt 补充
多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同 的状态。不同位置定义的变量和对象,其作用域,可见性,生存期都不同。程序模需要协作共同完成整个系统的功能,...
本文对于面向的对象的基本概念进行了介绍,包括类、状态、行为、封装、共生、内聚、领域集,帮助你理解什么是OO及发现你的程序中所存在的设计问题。
下面关于对象概念的描述中,_______是错误的。(B) A.对象代表着正在创建的系统中的一个实体 B.对象就是C语言中的结构体变量 C.对象是一个状态和操作(或方法)的封装体 D.对象之间的信息传递是通过消息进行的
面向对象设计的概念 21 面向对象的设计方法 21 第三章 UML概述 22 UML对软件工程的重大影响 22 UML的概念模型 22 UML的建模思想 23 第四章 用UML建模 24 第一节 建模概念 24 系统、模型和视图 24 概念和现象 25 数据...
1)对象(Object 可以对其做事情的一些东西 一个对象有状态 行为和标识三种属性 2)类(class 一个共享相同结构和行为的对象的集合 3)封装(encapsulation :第一层意思:将数据和操作捆绑在一起 创造出一个新...
有形性 创建具有状态的有形对象的概念(例如有限状态机)
什么是对象 对象是一件事,一个实体,一个名词,概括来说:万物皆是对象 一个对象保存了某些信息,并知道如何执行某些操作 对象的状态和行为 对象具有状态,状态是对对象的一个或多个属性的描述(如:一个灯 ...
每个对象都具有各自的状态特征(也可以称为属性)及行为特征(方法),java就是通过对象之间行为的交互来解决问题的。面向对象(Object Oriented)的英文缩写是OO,它是一种设计思想。从20世纪60年代提出面向对象的...
5.8 state(状态)—对象行为型模式 201 5.9 strategy(策略)—对象行为型 模式 208 5.10 template method(模板方法) —类行为型模式 214 5.11 visitor(访问者)—对象行为型 模式 218 5.12 行为模式的...
对象:对象是类的一个实例,有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。 类:类是一个模板,它描述一类对象的行为和状态。 方法:方法就是行为,一个类可以有...
接口的概念 •接口定义的是多个类共同的行为规范,这些行为是与外部交流的通道,这就意味着接口里通常是定义一组公用的 方法。 •接口体现了规范与实现分离的设计。 接口的定义 •和类...