我的流具有CPU绑定和IO绑定阶段的均匀混合(每个IO阶段后跟一个CPU阶段).我想要做的是将IO操作放在与流的其余部分不同的调度程序上.
在传统的基于演员的Akka应用程序中,我可以将我的IO演员放在具有大量线程的固定线程池调度程序上,同时将CPU绑定的actor放在具有少量线程的fork连接池中(一些多个,理想情况下为1)核心数量).这应该减少CPU绑定参与者的线程切换浪费的时间,同时通过在IO上阻塞大量线程来增加吞吐量.
这种理解对吗？如果没有,为什么？如果是,那么如何将我的IO绑定阶段(流)放在与流的其余部分分开的调度程序上？
我试过关闭自动融合,这确实有帮助.但它的吞吐量仍远低于几乎相当于Akka的产量.
这是一个代码片段 -
type Gateway struct {
Svc1 svc1.Interface
Svc2 svc2.Interface
}
func (g *Gateway) GetClient(service string) interface{} {
ps := reflect.ValueOf(g)
s := ps.Elem()
f := s.FieldByName(strings.Title(service))
return f.Interface()
}
func (g *Gateway) Invoke(service string, endpoint string, args...
interface{}) []reflect.Value {
log.Info("Gateway.Invoke " + service + "." + endpoint)
inputs := make([]reflect.Value, len(args))
for i, _ := range args {
inputs[i] = reflect.ValueOf(args[i])
}
client := g.GetClient(service)
return reflect.ValueOf(client).Elem().MethodByName(endpoint).Call(inputs)
}
GetClient("svc1") 工作正常。
但是，当我调用 Invoke("svc1", "endpoint1", someArg) 时，它会恐慌地说 -
reflect: call …我的流有一个Flow,其输出是List [Any]对象.我希望有一个mapAsync,后跟一些其他阶段,每个阶段处理一个单独的元素而不是列表.我怎样才能做到这一点？
实际上我想连接输出
Flow[Any].map { msg =>
someListDerivedFrom(msg)
}
被消费 -
Flow[Any].mapAsyncUnordered(4) { listElement =>
actorRef ? listElement
}.someOtherStuff
我该怎么做呢？
我想做这样的事情 -
class MyActor extends Actor {
....
override def receive = {
case msg =>
.... // do something
Future {
... // calculate response
sender ! response
}
}
}
// in some other code -
val future = myActorRef ? msg
future.onSuccess {
....
}
这会有用吗？换句话说,如果响应是在"接收"方法完成之前发回的,Akka的"请求"实现是否关心？
我有两个这样的案例类 -
case class GetList()
case class Add(num: Int)
我有一个演员,其接收方法如下所示 -
override def receive() = {
case a: Add => // do something
case g: GetList => // do something
case x: Any => // something
}
我叫演员为 -
ref ! Add(1)
ref ! GetList
对于Add(1)消息,我得到了一个点击:添加接收.但是对于GetList消息,它将转到x:Any.仔细观察后,我发现我得到的实例是GetList $类型,通常表示"对象".
谁在进行这种转换？为什么？这种奇怪的行为背后的理由是什么？
这就是我想要做的 -
class A(some args) {
var v: SomeType = null
def method1(args) = {
v = something1
...
method3
}
def method2(args) = {
v = something2
...
method3
}
def method3 = {
// uses v
}
}
在这种特定情况下,方法1和2是互斥的,并且它们中的任何一个在A的实例的生命周期中恰好被调用一次.此外,v被分配一次.我宁愿把它变成val.但是因为我需要method2或method3的上下文来初始化v,所以我不能在构造函数中这样做.
怎么能实现这种"val"行为？我可以考虑修改method1和method2来应用方法,但我不喜欢这个想法.此外,方法1和2具有相同的参数签名(因此应用将需要更多信息来区分这两种类型的调用).