有狀態和無狀態的區別

TZQ_DO_Dreamer發表於2014-12-21

基本概念： 

有狀態就是有資料儲存功能。有狀態物件(Stateful Bean)，就是有例項變數的物件 ，可以儲存資料，是非執行緒安全的。在不同方法呼叫間不保留任何狀態。

無狀態就是一次操作，不能儲存資料。無狀態物件(Stateless Bean)，就是沒有例項變數的物件 .不能儲存資料，是不變類，是執行緒安全的。

程式碼更好理解：

Java程式碼
  1.   
  2. public   class  StatefulBean {   
  3.   
  4.      public   int  state;   
  5.      // 由於多執行緒環境下，user是引用物件，是非執行緒安全的   
  6.      public  User user;   
  7.   
  8.      public   int  getState() {   
  9.          return  state;   
  10.     }   
  11.   
  12.      public   void  setState( int  state) {   
  13.          this .state = state;   
  14.     }   
  15.   
  16.      public  User getUser() {   
  17.          return  user;   
  18.     }   
  19.   
  20.      public   void  setUser(User user) {   
  21.          this .user = user;   
  22.     }   
  23. }   
  24.   
  25.   
  26. public   class  StatelessBeanService {   
  27.   
  28.      // 雖然有billDao屬性，但billDao是沒有狀態資訊的，是Stateless Bean.   
  29.     BillDao billDao;   
  30.   
  31.      public  BillDao getBillDao() {   
  32.          return  billDao;   
  33.     }   
  34.   
  35.      public   void  setBillDao(BillDao billDao) {   
  36.          this .billDao = billDao;   
  37.     }   
  38.   
  39.      public  List<User> findUser(String Id) {   
  40. return   null ;   
  41.     }   
  42. }  


單例模式中的有狀態和無狀態: 
單例類可以是有狀態的（stateful），一個有狀態的單例物件一般也是可變（mutable）單例物件 。 有狀態的可變的單例物件常常當做狀態庫（repositary）使用。比如一個單例物件TaskCache（Spring中配為singleton）可以 持有一個AtomicLong型別的屬性，用來給一個系統提供一個數值惟一的序列號碼，作為任務通迅管理的ID生成器。同時，一個單例類也可以持有一個聚 集，從而允許儲存多個狀態，如示例中的ExpiringMap快取任務列表。
程式碼示例：

Java程式碼
  1. import  java.util.concurrent.atomic.AtomicLong;   
  2.   
  3. import  org.apache.mina.util.ExpiringMap;   
  4.   
  5.   
  6. public   class  TaskCache {   
  7.   
  8.      // 請求超時   
  9.      private   short  requestTimeout;   
  10.   
  11.      // 這個快取Map是執行緒安全,並且有定時超時功能   
  12.      private  ExpiringMap<String, Object> tasksMap =  new  ExpiringMap<String, Object>();   
  13.   
  14.      // 執行緒安全的原子類,示例有狀態的單例類   
  15.      private   static  AtomicLong seqNo =  new  AtomicLong( 1 );   
  16.   
  17.      // 示例有狀態的單例類   
  18.      public  Long nextSeqNo() {   
  19.          return  seqNo.getAndIncrement();   
  20.     }   
  21.   
  22.      public   void  setRequestTimeout( short  requestTimeout) {   
  23.          this .requestTimeout = requestTimeout;   
  24.     }   
  25.   
  26.      // 啟動過期檢測   
  27.      public   void  startExpiring() {   
  28.         tasksMap.getExpirer().setTimeToLive(requestTimeout);   
  29.         tasksMap.getExpirer().startExpiringIfNotStarted();   
  30.     }   
  31.   
  32.      // 停止過期檢測   
  33.      public   void  stopExpiring() {   
  34.         tasksMap.getExpirer().stopExpiring();   
  35.     }   
  36.   
  37.      // 取任務列表.   
  38.      public  Object getTasks(String key) {   
  39.          return  tasksMap.get(key);   
  40.     }   
  41.   
  42.      // 去除任務列表.   
  43.      public  Object removeTasks(String key) {   
  44.          return  tasksMap.remove(key);   
  45.     }   
  46.   
  47.      // 新增任務列表.   
  48.      public   void  addTasks(String key, Object value) {   
  49.         tasksMap.put(key, value);   
  50.     }   
  51. }  



單例類也可以是沒有狀態的（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都是有狀態 資訊的。

Java程式碼
  1.   
  2. public   class  UnSafeServlet HttpServlet{   
  3.        
  4.     User user;   
  5.     PrintWriter out;   
  6.        
  7.      public   void  doGet (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{   
  8.          //do something...   
  9.     }   
  10. }  


Out,Request,Response,Session,Config,Page,PageContext是執行緒安全的,Application在整個系統內被使用,所以不是執行緒安全的.

2.Struts1也是基於單例模式實現，也就是隻有一個Action例項供多執行緒使用。預設的模式是前臺頁面資料通過actionForm傳入，在 action中的excute方法接收，這樣action是無狀態的，所以一般情況下Strunts1是執行緒安全的。如果Action中用了例項變數，那 麼就變成有狀態了，同樣是非執行緒安全的。像下面這樣就是執行緒不安全的。

Java程式碼
  1.   
  2. public   class  UnSafeAction1  extends  Action {   
  3.   
  4.      // 因為Struts1是單例實現，有狀態情況下，物件引用是非執行緒安全的   
  5.     User user;   
  6.   
  7.      public   void  execute() {   
  8.          // do something...   
  9.     }   
  10.   
  11.      public  User getUser() {   
  12.          return  user;   
  13.     }   
  14.   
  15.      public   void  setUser(User user) {   
  16.          this .user = user;   
  17.     }   
  18. }    

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.

相關文章