protoactorgo框架学习

目录

• 前言
  
  
  
  • actor模型与csp模型
  
  
  • 选择版本
  
  
  • 全部源码
  
  
  
  


• 参考

前言

业务中，大量使用了protoactor-go框架作为消息处理，用来避免高并发。现对其进行学习。

actor模型与csp模型

《unix 网络编程-进程间通信》，提到，有消息传递、共享内存等两大类实现方法。其中消息传递（前提是内容拷贝）避免了并发；同时共享内存则面临着同步问题（如：并发访问带来了加锁）

actor来源与Erlang语言，强调，每个actor是一个实体，通信通过消息传递，每一个actor拥有自己消息队列，持续处理消息。MPSC（multi-producer signal-consumer）。

csp基本原则就是『通过通信来实现共享内存，不要通过共享内存来实现通信』。也就是提倡尽可能通过消息传递的方式。

这两者有异曲同工之妙，同是指两者都希望通过消息传递来实现进程间的通信，带来的好处是避免并发，可以降低编程带来的心智负担；异则是两者着重点稍有不同，actor强调actor实体，消息队列则是actor实体的一部分，而csp则强调消息队列，突出了channel这一数据结构体的存在，goroutine则明显没有actor实体的地位突出。

但总体而言，actor框架与go相结合，能实现一些令人意想不到的效果。让我们开始吧。

选择版本

git checkout e866f39


全部源码

package main
import "fmt"
import "bufio"
import "os"
func main() {
myActor := ActorOf(new(MyActor))
myActor.Tell(Hello{Name: "Roger"})
myActor.Tell(Hello{Name: "Go"})
bufio.NewReader(os.Stdin).ReadString('\n')
}
type ActorRef interface {
Tell(message interface{})
SendSystemMessage(message interface{})
}
type ChannelActorRef struct {
actorCell *ActorCell
}
func (ref *ChannelActorRef) Tell(message interface{}) {
ref.actorCell.userMailbox <- message
}
func (ref *ChannelActorRef) SendSystemMessage(message interface{}) {
ref.actorCell.userMailbox <- message
}
type Actor interface {
Receive(message interface{})
}
func ActorOf(actor Actor) ActorRef {
userMailbox := make(chan interface{}, 100)
systemMailbox := make(chan interface{}, 100)
cell := &ActorCell{
userMailbox: userMailbox,
systemMailbox: systemMailbox,
actor: actor,
}
ref := ChannelActorRef{
actorCell: cell,
}
go func() {
for {
select {
case sysMsg := <-systemMailbox:
//prioritize system messages
cell.invokeSystemMessage(sysMsg)
default:
//if no system message is present, try read user message
select {
case userMsg := <-userMailbox:
cell.invokeUserMessage(userMsg)
default:
}
}
}
}()
return &ref
}
type ActorCell struct {
userMailbox chan interface{}
systemMailbox chan interface{}
actor Actor
}
func (cell *ActorCell) invokeSystemMessage(message interface{}) {
fmt.Printf("Received system message %v\n", message)
}
func (cell *ActorCell) invokeUserMessage(message interface{}) {
cell.actor.Receive(message)
}
type MyActor struct{ messageCount int }
type Hello struct{ Name string }
func (state *MyActor) Receive(message interface{}) {
switch msg := message.(type) {
default:
fmt.Printf("unexpected type %T\n", msg) // %T prints whatever type t has
case Hello:
fmt.Printf("Hello %v\n", msg.Name) // t has type bool
state.messageCount++
}
}


参考

https://www.cnblogs.com/XiaoXiaoShuai-/p/16001285.html

https://blog.csdn.net/screscent/article/details/90401707?spm=1001.2014.3001.5501