设计模式之状态

一.简介

程序设计中有些对象是有状态的对象。当有状态的对象与外部事件产生互动时，其内部状态会发生改变，从而使得其行为也随之发生改变。

传统的处理方法是采用if-else 语句判断处理多种状态，状态模式的思想是：把“判断逻辑”提取出来，放到一系列的状态类当中，状态对象在其内部状态发生改变时改变其行为。

模式结构：
1.环境（Context）角色：它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。

2.抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。

3.具体状态（Concrete State）角色：实现抽象状态所对应的行为。

二.实现

线程状态简单转换：新建、就绪、运行、阻塞、停止

package com.vincent;




/**
 * 设计模式
 *
 */
public class App {
    public static void main( String[] args ) throws Exception {
        ThreadContext context = new ThreadContext();
        context.start();
        context.getCpu();
        context.block();
        context.getCpu();
        context.stop();
    }
}



class ThreadContext{
    AbstructThreadState state = new New();


    public AbstructThreadState getState() {
        return state;
    }


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


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

    public void getCpu(){
        state.getCpu(this);
    }

    public void block(){
        state.block(this);
    }

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



abstract class AbstructThreadState{

    static final int STATUS_NEW = 0;
    static final int STATUS_RUNNABLE = 1;
    static final int STATUS_RUNNING = 2;
    static final int STATUS_BLOCKED = 4;
    static final int STATUS_STOP = 8;

    //运行状态
    int status;

    public void start(ThreadContext context){
        throw new IllegalStateException();
    }

    public void getCpu(ThreadContext context){
        throw new IllegalStateException();
    }

    public void block(ThreadContext context){
        throw new IllegalStateException();
    }

    public void stop(ThreadContext context){
        throw new IllegalStateException();
    }

}


/**
 * 新建状态
 */
class New extends AbstructThreadState{

    @Override
    public void start(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_NEW){
            context.setState(new Runnable());
            context.getState().status = AbstructThreadState.STATUS_RUNNABLE;
            System.out.println("程序处于Runnable状态");
        }
        else{
            throw new IllegalStateException();
        }

    }
}


/**
 * 就绪状态
 */
class Runnable extends AbstructThreadState{
    @Override
    public void getCpu(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNABLE){
            context.setState(new Running());
            context.getState().status = AbstructThreadState.STATUS_RUNNING;
            System.out.println("程序处于running状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}


/**
 * 运行状态
 */
class Running extends AbstructThreadState{

    @Override
    public void block(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNING){
            context.setState(new Block());
            context.getState().status = AbstructThreadState.STATUS_BLOCKED;
            System.out.println("程序处于blocked状态");
        }
        else{
            throw new IllegalStateException();
        }
    }

    @Override
    public void stop(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNING){
            context.setState(new Stop());
            context.getState().status = AbstructThreadState.STATUS_STOP;
            System.out.println("程序处于stop状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}

/**
 * 阻塞状态
 */
class Block extends AbstructThreadState{

    @Override
    public void getCpu(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_BLOCKED){
            context.setState(new Running());
            context.getState().status = AbstructThreadState.STATUS_RUNNING;
            System.out.println("程序处于running状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}


/**
 * 停止状态
 */
class Stop extends AbstructThreadState{


}

效果：

三.总结

1.状态模式把对象状态变化操作委托给状态类操作