对象的行为依赖于其状态：当一个对象的行为随着其内部状态的变化而变化时，可以使用状态模式。例如，在电子商务系统中，订单可能经历多种状态（如创建、支付、发货、完成和取消），每个状态下可以执行的操作不同，状态模式可以很好地管理这种状态的变化。
代码中包含大量的条件语句：当代码中包含大量的条件语句，并且这些条件语句表示对象的不同状态时，可以使用状态模式。状态模式可以将不同状态的处理分离出来，使得代码更加清晰。
对象的状态转换规则非常复杂时，可以使用状态模式。状态模式可以将状态转换规则封装在状态类中，使得状态转换更加灵活、可扩展。
需要增加新的状态：当需要增加新的状态时，可以使用状态模式。通过增加新的状态类，可以很容易地扩展状态模式。
对象具有多种状态且状态之间存在转换关系：当对象的行为随着其内部状态的变化而变化，并且这些状态之间存在复杂的转换逻辑时，状态模式非常有用。例如，在游戏编程中，可以根据游戏的不同阶段（如游戏开始、进行中、结束）来改变游戏逻辑。
并发编程中的线程状态管理：在并发编程中，可以根据线程的不同状态（如运行、等待、阻塞）来改变线程的行为。

状态模式简单实现

定义抽象状态

public abstract class State {

    /*操作状态的方法*/
    public abstract void Handle(Context context);
}

定义操作状态上下文

public class Context {

    /*定义状态*/
    private State state;

    public Context(){
        state = new ConcreteStateA();
    }

    /*在Context中可以封装对状态的操作*/

    /*设置新状态*/
    public void setState(State state){
        this.state = state;
    }

    /*读取状态*/
    public State getState()
    {
        return(state);
    }
    /*处理状态*/
    public void Handle()
    {
        state.Handle(this);
    }
}

具体状态A

public class ConcreteStateA extends State{

    public void Handle(Context context)
    {
        System.out.println("当前状态是 A.");
        /*重新设置新状态 触发将状态A转换为状态B*/
        context.setState(new ConcreteStateB());
    }
}

具体状态B

public class ConcreteStateB extends State{

    public void Handle(Context context)
    {
        System.out.println("当前状态是 B.");
        /*设置新状态B*/
        context.setState(new ConcreteStateA());
    }
}

Client

public class State_test_API {

    public static void main(String[] args) {

        /*创建状态上下文*/
        Context context = new Context();
        /*处理状态,调用接口中的方法*/
        context.Handle();
    }
}

状态模式实现线程状态转换

设计

多线程存在 5 种状态，分别为新建状态、就绪状态、运行状态、阻塞状态和死亡状态，各个状态当遇到相关方法调用或事件触发时会转换到其他状态，其状态转换规律如图所示:

现在先定义一个抽象状态类（TheadState），然后为上图所示的每个状态设计一个具体状态类，它们是新建状态（New）、就绪状态（Runnable ）、运行状态（Running）、阻塞状态（Blocked）和死亡状态（Dead），每个状态中有触发它们转变状态的方法，环境类（ThreadContext）中先生成一个初始状态（New），并提供相关触发方法，线程状态转换程序的结构图如下图所示：

定义抽象状态

/*封装线程状态*/
public abstract class ThreadState {

    protected String stateName; //状态名
}

抽象状态，封装状态锁对应的行为，当状态发生改变时，触发此行为调用;

环境上下文

public class ThreadContext {
    /*封装线程状态上下文 服务对状态进行操作*/
    /*保存线程状态对象*/
    private ThreadState state;

    public 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);
    }
}

新建线程

public class New extends ThreadState{

    public New() {
        stateName="新建状态";
        System.out.println("当前线程处于:新建状态.");
    }

    /*启动新线程*/
    public void start(ThreadContext hj) {
        System.out.print("调用start()方法-->");
        if(stateName.equals("新建状态")) {
            /*将新建状态的线程转换为可运行状态*/
            hj.setState(new Runnable());
        } else {
            System.out.println("当前线程不是新建状态，不能调用start()方法.");
        }
    }
}

可运行状态

public class Runnable extends ThreadState{

    public Runnable() {
        stateName="就绪状态";
        System.out.println("当前线程处于：就绪状态.");
    }

    public void getCPU(ThreadContext hj) {
        System.out.print("获得CPU时间-->");
        if(stateName.equals("就绪状态")) {
            /*将可运行状态线程转换为运行状态*/
            hj.setState(new Running());
        } else {
            System.out.println("当前线程不是就绪状态，不能获取CPU.");
        }
    }
}

运行态线程

public class Running extends ThreadState{

    public Running() {
        stateName="运行状态";
        System.out.println("当前线程处于：运行状态.");
    }

    /*挂起线程*/
    public void suspend(ThreadContext hj) {
        System.out.print("调用suspend()方法-->");
        if(stateName.equals("运行状态")) {
            /*运行状态的线程转换为阻塞状态*/
            hj.setState(new Blocked());
        } else {
            System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
        }
    }
    /*暂停线程*/
    public void stop(ThreadContext hj) {
        System.out.print("调用stop()方法-->");
        if(stateName.equals("运行状态")) {
            /*运行状态的线程转换为死亡状态*/
            hj.setState(new Dead());
        } else {
            System.out.println("当前线程不是运行状态，不能调用stop()方法.");
        }
    }
}

阻塞线程

public class Blocked extends ThreadState {

    public Blocked() {
        stateName="阻塞状态";
        System.out.println("当前线程处于：阻塞状态.");
    }

    public void resume(ThreadContext hj) {
        System.out.print("调用resume()方法-->");
        if(stateName.equals("阻塞状态")) {
            /*阻塞状态线程转换为可运行状态*/
            hj.setState(new Runnable());
        } else {
            System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");
        }
    }
}

死亡线程

public class Dead extends ThreadState{

    public Dead() {
        stateName="死亡状态";
        System.out.println("当前线程处于：死亡状态.");
    }
}

客户端

public class ThreadState_test_API {

    public static void main(String[] args) {

        /*创建状态上下文*/
        ThreadContext context = new ThreadContext();
        context.start();
        context.getCPU();
        context.suspend();
        context.resume();
        context.getCPU();
        context.stop();
    }
}

上述实现中，线程之间存在多种状态转换，我们通过封装将不同状态封装为不同的对象，然后在不同状态之间分别相互触发状态转换;

状态模式扩展

在有些情况下，可能有多个环境对象需要共享一组状态，这时需要引入享元模式，将这些具体状态对象放在集合中供程序共享，其结构图如图所示：

共享状态模式的不同之处是在环境类中增加了一个 HashMap 来保存相关状态，当需要某种状态时可以从中获取，其程序代码如下：

class ShareContext
{
    private ShareState state;
    private HashMap<String, ShareState> stateSet=new HashMap<String, ShareState>();
    public ShareContext()
    {
        state=new ConcreteState1();
        stateSet.put("1", state);
        state=new ConcreteState2();
        stateSet.put("2", state);
        state=getState("1");
    }
    //设置新状态
    public void setState(ShareState state)
    {
        this.state=state;
    }
    //读取状态
    public ShareState getState(String key)
    {
        ShareState s=(ShareState)stateSet.get(key);
        return s;
    }
    //对请求做处理
    public void Handle()
    {
        state.Handle(this);
    }
}