protoactor-go框架学习

目录

• 前言
  • 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