狀態機的一般實現

相關概念

• 有限狀態機/finite-state machine (FSM)： 具有有限狀態數目的狀態機，是最常用的狀態機，也是一般討論狀態機時所指的對象
• 無限狀態機/Infinite State Machine：具有無限狀態數目的狀態機，很少用到
• 狀態/state：狀態可達到的某個狀態
• 狀態轉換/transition：狀態機的從一個狀態轉變為另一個狀態
• 輸入/input/事件/event：可被被狀態機接收并處理的事件輸入，可能導致狀態變動

一般狀態的UML表示如下：

狀態機的一般實現

一個播放器示例

public enum State {

    IDLE,

    DATA_SOURCE,

    PREPARING,

    PREPARED,

    STARTING,

    STARTED,

    BUFFERING,

    READY,

    SWITCHING_PROGRAM,

    SWITCHING_CHANNEL,

    SWITCHING_DEFINITION,

    SWITCHING_ENGINE,

    STOPPING,

    RELEASING,

    ERROR
}

狀態的順序很重要，盡量按照stack的形式，對于特殊狀態特殊處理，比如error。

public class Event {

    public static class SetDataSourceEvent extends LoopEvent {
        public Uri uri;

        public SetDataSourceEvent() {}

        public SetDataSourceEvent(Uri uri) {
            this.uri = uri;
        }
    }

    public static class PrepareEvent extends LoopEvent {}

    public static class StartEvent extends LoopEvent {}

    public static class SwitchChannelEvent extends LoopEvent {
        public int cateIndex;
        public int channelIndex;

        public SwitchChannelEvent() {}

        public SwitchChannelEvent(int cateIndex, int channelIndex) {
            this.cateIndex = cateIndex;
            this.channelIndex = channelIndex;
        }
    }

    public static class SwitchDefinitionEvent extends LoopEvent {
        public int definition;

        public SwitchDefinitionEvent() {}

        public SwitchDefinitionEvent(int definition) {
            this.definition = definition;
        }
    }

    public static class SwitchEngineEvent extends LoopEvent {
        public String engine;

        public SwitchEngineEvent() {}

        public SwitchEngineEvent(String engine) {
            this.engine = engine;
        }
    }

    public static class StopEvent extends LoopEvent {}
}

public abstract class Action {
    protected abstract void doAction() throws Exception;
}

public class Action1 extends Action {
    protected void doAction() throws Exception {
        // xxxx
        // update state
    }
}

...

public abstract class LoopStateMachine {

    private ActionThread mActionThread = new ActionThread("LoopActionThread");

    private BlockingQueue<Action> mActionQueue = new ArrayBlockingQueue<>(100);

    private State mState;

    public void sendEvent(Event event) {
        // 根據event創建action并塞入mActionQueue
    }

    private class ActionThread extends Thread {
        public ActionThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            super.run();
            while (true) {
                try {
                    LoopAction action = mActionQueue.take();
                    action.doAction();
                } catch (Exception e) {
                    Logger.w(TAG, "$ActionThread#run(): exception", e);

                    mState = State.ERROR;
                    // 繼續
                }
            }
        }
    }
}