設計模式之狀態模式-有解無憂

狀態模式又稱狀態物件模式，屬于行為型模式；狀態模式允許一個物件在其內部狀態改變的時候改變其行為，這個物件看上去就像是改變了它的類一樣，狀態模式把所研究的物件的行為包裝在不同的狀態物件里，每一個狀態物件都屬于一個抽象狀態類的子類，狀態模式的意圖是讓一個物件在其內部狀態改變的時候，其行為也隨之改變，

對這種有狀態的物件編程，傳統的解決方案是：將這些所有可能發生的情況全都考慮到，然后使用 if-else 或 switch-case 陳述句來做狀態判斷，再進行不同情況的處理，但是顯然這種做法對復雜的狀態判斷存在天然弊端，條件判斷陳述句會過于臃腫，可讀性差，且不具備擴展性，維護難度也大，且增加新的狀態時要添加新的 if-else 陳述句，這違背了“開閉原則”，不利于程式的擴展，

以上問題如果采用狀態模式就能很好地得到解決，狀態模式把相關“判斷邏輯”提取出來，用各個不同的類進行表示，系統處于哪種情況，直接使用相應的狀態類物件進行處理，這樣能把原來復雜的邏輯判斷簡單化，消除了 if-else、switch-case 等冗余陳述句，代碼更有層次性，并且具備良好的擴展力，

狀態模式的UML類圖如下：

如上圖所示，狀態模式涉及到抽象狀態角色、具體狀態角色、環境角色三種角色：

抽象狀態角色：定義一個介面，用以封裝環境物件的一個特定的狀態所對應的行為
具體狀態角色：每一個具體狀態類都實作了環境的一個狀態所對應的行為
環境角色：定義客戶端所感興趣的介面，并且保留一個具體狀態類的實體，并負責具體狀態的切換

java多執行緒狀態轉換的例子

我們都知道在java中，多執行緒有5種狀態，分別為新建狀態、就緒狀態、運行狀態、阻塞狀態和死亡狀態，如下圖所示：

例子的UML類圖如下：

抽象狀態角色：

package com.charon.state;

/**
 * @className: ThreadState
 * @description: 抽象狀態類
 * @author: charon
 * @create: 2022-04-09 21:20
 */
public abstract class ThreadState {

    /**
     * 執行緒狀態名稱
     */
    protected String stateName;

}

具體狀態角色：

package com.charon.state;

/**
 * @className: New
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:30
 */
public class New extends ThreadState{

    public New() {
        stateName = "New";
        System.out.println("當前狀態處于：新建狀態.");
    }

    public void start(ThreadContext context){
        System.out.print("呼叫start()方法-->");
        if("New".equalsIgnoreCase(stateName)){
            context.setState(new Runnable());
        }else{
            System.out.println("當前狀態不是新建狀態，不能呼叫start()方法");
        }
    }
}

package com.charon.state;

/**
 * @className: Runnable
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:34
 */
public class Runnable extends ThreadState {

    public Runnable() {
        stateName = "Runnable";
        System.out.println("當前執行緒處于：就緒狀態.");
    }

    public void getCPU(ThreadContext hj) {
        System.out.print("獲得CPU時間-->");
        if (stateName.equals("Runnable")) {
            hj.setState(new Running());
        } else {
            System.out.println("當前執行緒不是就緒狀態，不能獲取CPU.");
        }
    }
}

package com.charon.state;

/**
 * @className: Running
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:34
 */
public class Running extends ThreadState {

    public Running() {
        stateName = "Running";
        System.out.println("當前執行緒處于：運行狀態.");
    }

    public void suspend(ThreadContext hj) {
        System.out.print("呼叫suspend()方法-->");
        if (stateName.equals("Running")) {
            hj.setState(new Blocked());
        } else {
            System.out.println("當前執行緒不是運行狀態，不能呼叫suspend()方法.");
        }
    }

    public void stop(ThreadContext hj) {
        System.out.print("呼叫stop()方法-->");
        if (stateName.equals("Running")) {
            hj.setState(new Dead());
        } else {
            System.out.println("當前執行緒不是運行狀態，不能呼叫stop()方法.");
        }
    }
}

package com.charon.state;

/**
 * @className: Blocked
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:35
 */
public class Blocked extends ThreadState {
    public Blocked() {
        stateName = "Blocked";
        System.out.println("當前執行緒處于：阻塞狀態.");
    }

    public void resume(ThreadContext hj) {
        System.out.print("呼叫resume()方法-->");
        if (stateName.equals("Blocked")) {
            hj.setState(new Runnable());
        } else {
            System.out.println("當前執行緒不是阻塞狀態，不能呼叫resume()方法.");
        }
    }
}

package com.charon.state;

/**
 * @className: Dead
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:35
 */
public class Dead extends ThreadState {

    public Dead() {
        stateName = "Dead";
        System.out.println("當前執行緒處于：死亡狀態.");
    }
}

環境角色:

package com.charon.state;

/**
 * @className: ThreadContext
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:32
 */
public class ThreadContext {
    private ThreadState state;

    ThreadContext() {
        state = new New();
    }

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

    public ThreadState getState() {
        return state;
    }

    public void start() {
        ((New) state).start(this);
    }

    public void getCPU() {
        ((Runnable) state).getCPU(this);
    }

    public void suspend() {
        ((Running) state).suspend(this);
    }

    public void stop() {
        ((Running) state).stop(this);
    }

    public void resume() {
        ((Blocked) state).resume(this);
    }
}

客戶端測驗：

package com.charon.state;

/**
 * @className: Client
 * @description:
 * @author: charon
 * @create: 2022-04-09 21:51
 */
public class Client {

    public static void main(String[] args) {
        ThreadContext context = new ThreadContext();
        context.start();
        context.getCPU();
        context.suspend();
        context.resume();
        context.getCPU();
        context.stop();
    }

}

列印：
    當前狀態處于：新建狀態.
    呼叫start()方法-->當前執行緒處于：就緒狀態.
    獲得CPU時間-->當前執行緒處于：運行狀態.
    呼叫suspend()方法-->當前執行緒處于：阻塞狀態.
    呼叫resume()方法-->當前執行緒處于：就緒狀態.
    獲得CPU時間-->當前執行緒處于：運行狀態.
    呼叫stop()方法-->當前執行緒處于：死亡狀態.

狀態模式的主要優點如下：

結構清晰，狀態模式將與特定狀態相關的行為區域化到一個狀態中，并且將不同狀態的行為分割開來，滿足“單一職責原則”，
將狀態轉換顯示化，減少物件間的相互依賴，將不同的狀態引入獨立的物件中會使得狀態轉換變得更加明確，且減少物件間的相互依賴，
狀態類職責明確，有利于程式的擴展，通過定義新的子類很容易地增加新的狀態和轉換，

狀態模式的主要缺點如下：

狀態模式的使用必然會增加系統的類與物件的個數，
狀態模式的結構與實作都較為復雜，如果使用不當會導致程式結構和代碼的混亂，
狀態模式對開閉原則的支持并不太好，對于可以切換狀態的狀態模式，增加新的狀態類需要修改那些負責狀態轉換的原始碼，否則無法切換到新增狀態，而且修改某個狀態類的行為也需要修改對應類的原始碼，

狀態模式的使用場景

一個物件的行為依賴于它所處的狀態，并且物件的行為必須隨著其狀態的改變而改變
物件在某個方法里依賴于一重或多重的條件轉移陳述句，其中有大量的代碼，狀態模式把條件轉移陳述句的每一個分支都包裝到一個單獨的類里，這使得這些條件轉移分支能夠以類的方式獨立存在和演化，維護這些獨立的類也就不在影響到系統的其他部分，

本文著作權歸Charon和博客園共有，原創文章，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/457620.html

標籤：設計模式

上一篇：OAuth 授權協議 | 都云原生時代了，我們應該多懂一點OAuth ？

下一篇：設計模式之狀態模式