最早的计算机是非实时的，编制好顺序任务，计算机一件一件执行，

然后在任务里，为了处理等待IO等操作，提供了异步IO指令，让CPU在IO阶段可以同时处理计算，

后来出现了分时操作系统，计算机有了进程概念，任务间互无关系，操作系统可以连接多终端（用户接口）的交互，

接着人们希望在单任务里，密集计算不影响用户界面（UI）交互，于是有了线程，

接着CPU出现了多核，多进程可以成倍地加快程序性能，

在互联网的时代，为了完成一项任务，我们可以用到互联网上的所有计算资源，

操作系统提供了异步API，线程API，较为现代的编程语言则提供了协程设施，
协程可以看作是“用户级别的线程”，它配合异步API，和线程API，更加灵活地使用并发资源，有些语言，比如golang，内建了对进程内并发的支持，kotlin则使用语言支持+库的方式细粒度地构建并发，

如果我们把云环境看做是"互联网操作系统"，我相信未来需要一种在这样操作系统下成熟的编程语言，它对于各种并发（线程，进程，多核，云）透明，用户可以在云环境的终端下，简单地利用云上的计算资源，

以下（仅）让我们想象中设计这样的编程语言，一些基本概念如下，以下籍 “stage"语言表示，

1.它是一种actor模型，actor可能存在于计算资源的任何一个节点上（云/进程/线程）

host

actor具有层级，actor的工作可能由子actor完成，(但子actor不一定和父actor在同一计算节点)

scope.png

actor运行时是动态的，通过 launch(Actor)创建，actor运行时可创建子actor，

launch Actor("manager") {
    on("recruit") {
        launch("worker");
        print("a new worker join");
    }
}

actor有生命周期，父actor销毁时，子actor也需要销毁，

{
  // ...
  launch Actor("manager") {
    on("recruit") {
      launch("worker"); // launch 默认在当前的Actor里launch，也可归属于另外的Actor, 这种情况属于借用，并不管理其生命周期
      print("a new worker join");
    }
  }
}

actor之间通过消息进行交互，actor的方法

{
    print(actorOf('b').name()) ;// 这时向可能远程的'b'发送一个请求，send(actorOf('b'), "name", continuation);
} // now manager & workers are disposed!</pre>

actor的方法可能返回，成功或失败，

try {
  print(actorOf('b').name())
} catch (ex) {
  print('fail to get respond')
}

actor提供了异步方法，取消亦是失败的一种，

thread1 = async {
    try {
      print(actorOf('b').name())
    } catch(ex) {
      print("must be a cancellation exception")
    }
}
thread1.cancel()

以上的一个“云操作系统”，如何实现呢，我的想法如下，

任何一段程序有一个所在的环境，在物理上，它是云上一个主机上的一个进程的一条线程上的一个任务对象（实际是一个coroutine，表示为状态机)，
它表示为 :<actorID>/<routineID>，如果actorID不存在于本地，向地址服务器请求host，

一个异步请求过程如下，假设当前调用远端方法，

actorOf('B').name()

如果'B‘不在本地，向地址服务器指请 ’B‘的host，
构造一条请求向host B发送，:<host B>/<actorID>/request?method=name&sender=<actorID_A>/<rountineID_A>"
host B调用actor的name方法，生成一个新的routine, 完成后，
构造一条回复向host A返回:<host A>/<actorID_A>/<routineID_A>/respone?result=...
当然也可返回fail:<host A>/<actorID_A>/<routineID_A>/fail?reason=...

这里的routine由底层的协程机制保证，当返回时，最终调用

coroutine.resume_with_result(...) // 或
coroutine.resume_with_fail(...)

Actor编程模型

Actor是一种并发方式，它把并发执行分解成Actor单元，Actor通过Message进行交互，

在我的设计里，event queue, mailbox, publish/subscribe 都在统一的模型里,

Actor是一种很方便图形化表示的编程模型

Actor M {
    data {
        ma {
            type = number,
            in,
        }
        mb {
            type = string,
            out,
        }
        mc {
            type = bool,
            out,
        }
        state {
            type = string
        }
    }
 
    // 定义和data基本一致，当然，都是类型定义
    event {
        born { type=number,  in } // explict
        quit { in }
        sendNews { out} // 可被触发
    }
     
    children {
        worker1 = Actor worker {
            // ...
        }
    }
     
    prefab {
        Actor worker {
            // ...
        }
    }
 
    handle {
        on(evt) {
            case(state) {
                onA,
            }
        }
    }
}

stage语言的并发设计

stage语言的并发设计

Actor编程模型