开发设计模式（二） ActiveObject模式

ActiveObject模式:

ActiveObject模式和Command模式的配合使用是实现多线程控制的一项古老的技术，该模式有多种使用方式，为许多工业系统提供了一个简单的多任务核心。

// 活动对象的工具类，封装添加命令的方法以及运行方法

class ActiveObjectEngine

{

    ArrayList itsCommands = new ArrayList();

    // 添加命令 //

    public void AddCommand(Command c)

    {

        itsCommands.Add(c);

    }

    // 运行命令，并且移除 //

    public void Run()

    {

        while (itsCommands.Count > )

        {

            Command c = (Command)itsCommands[];

            itsCommands.RemoveAt();

            c.Execute();

        }

    }

}

Run()函数只是遍历列表，执行并移除每个命令。如此，似乎也没给人很深刻的印象，但是发挥一下想象，如果链表中的command对象会克隆自己并把克隆对象放到链表的尾部，会是什么情况？可见这个链表不会为空，Run()永远不会返回。

// 唤醒命令，类似于undo()函数 //

class WakeUpCommand : Command

{

 public bool executed = false;

 public void Execute()

 {

  executed = true;

 }

}

// 睡眠命令 //

class SleepCommand : Command

{

    private Command wakeupCommand = null;

    private ActiveObjectEngine engine = null;

    private long sleepTime = ;

    private System.DateTime startTime;

    private bool started = false;

    public SleepCommand(long milliseconds, ActiveObjectEngine e,Command wakeupCommand)

    {

        sleepTime = milliseconds;

        engine = e;

        this.wakeupCommand = wakeupCommand;

    }

    public void Execute()

    {

        System.DateTime current = DateTime.Now;

        if (!started)

        {

            Debug.Log("one..................add this");

            started = true;

            startTime = current;

            engine.AddCommand(this);

        }

        else

        {

            TimeSpan elapsedTime = current - startTime;

            Debug.Log("__" + elapsedTime.TotalMilliseconds);

            if (elapsedTime.TotalMilliseconds < sleepTime)

            {

                engine.AddCommand(this);

                Debug.Log("..................add this");

            }

            else

            {

                engine.AddCommand(wakeupCommand);

                Debug.Log("..................add wakeup");

            }

        }

    }

}

可见它的构造方法有三个参数，第一个是延迟时间，第二个是活动对象的工具类，第三个是唤醒命令类，分析代码可以看出，当前时间小于延迟时间的时候，会重复的调用自身（sleepCommand）的excute(),当大于延迟时间，就调用wakeupCommand，表示任务处理结束。

然后调用以上代码：

// 这里测试环境是unity3d，所以会看到Start()函数

    void Start () {

        WakeUpCommand wakeup = new WakeUpCommand();

        ActiveObjectEngine e = new ActiveObjectEngine();

        SleepCommand c = new SleepCommand(, e, wakeup);

        e.AddCommand(c);

        DateTime start = DateTime.Now;

        e.Run();

        DateTime stop = DateTime.Now;

        TimeSpan sleepTime = stop - start;

        print("command end:" + wakeup.executed + "  run time:" + sleepTime.TotalMilliseconds);

    }

打印的结果，wakeup.executed ： true, 运行时间是一个大于900毫秒的数。

我们可以将该程序和等待一个事件的多线程程序做一个对比，多线程程序等待的时候，通常是使用操作系统调用来阻塞自己直到事件发生。

而上面的代码并没有阻塞，采用该技术的变体实现多线程是一个很优秀的方式，这种类型的线程称为run-to-completion任务（RTC），它的优点就是共享同一个运行时栈。这在需要大量线程的内存受限系统中是一个强大的优势。

以下代码是一个多线程的实例

class DelayedTyper : Command

{

    private long itsDelay;

    private char itsChar;

    private static bool stop = false;

    private static ActiveObjectEngine engine = new ActiveObjectEngine();

    class StopCommand : Command

    {

        public void Execute()

        {

            DelayedTyper.stop = true;

        }

    }

    public DelayedTyper(long delay, char c)

    {

        itsDelay = delay;

        itsChar = c;

    }

    public void Execute()

    {

        Debug.Log(itsChar);

        if (!stop)

        {

            DelayAndRepeat();

        }

    }

    public void DelayAndRepeat()

    {

        engine.AddCommand(new SleepCommand(itsDelay, engine, this));

    }

    public static void Go()

    {

        engine.AddCommand(new DelayedTyper(, ''));

        engine.AddCommand(new DelayedTyper(, ''));

        engine.AddCommand(new DelayedTyper(, ''));

        engine.AddCommand(new DelayedTyper(, ''));

        Command stopCommand = new StopCommand();

        engine.AddCommand(new SleepCommand(, engine, stopCommand));

        engine.Run();

    }

}

在Start函数添加：

DelayedTyper.Go();

打印的结果可以看出，每次的都会不一样，这是因为CPU的时钟和实时时钟没有完美的同步，这种不确定的行为不就是多线程系统的特点么。

巴特西

开发设计模式（二） ActiveObject模式

最新文章

热门文章