前言
tokio是Rust中使用最广泛的异步Runtime，它性能高、功能丰富、便于使用，是使用Rust实现高并发不可不学的一个框架
Actor 背后的基本思想是产生一个独立的任务，该任务独立于程序的其他部分执行某些工作。 通常，这些参与者通过使用消息传递信道与程序的其余部分进行通信。 由于每个 Actor 独立运行，因此使用它们设计的程序自然是并行的。 Actor 的一个常见用法是为 Actor 分配你要共享的某些资源的专有所有权，然后让其他任务通过与 Actor 通信来间接访问彼此的资源。 例如，如果要实现聊天服务器，则可以为每个连接生成一个任务，并在其他任务之间路由一个聊天消息的主任务。 十分有用，因为主任务可以避免必须处理网络IO，而连接任务可以专门处理网络IO；
为什么一定要用actor,这里只是仿照go项目里一部分，go 用的就是actor;
1：环境
rust1.75
ide rustrover64
2:设计及实现
这里使用类似单点登录模式，
useractor
先看go的
一共3个协程/future
接受网络消息 一个协程/future
发送网络消息 一个协程/future
逻辑处理 一个协程/future
协程/future间通信 直接用mpsc
world actor/accmgr 管理useractor 登录，踢人，广播等
一共1个协程/future 处理逻辑消息
rust 版
useractor
说明 receiver: mpsc::UnboundedReceiver, logic future 接受消息并处理
sendclient: mpsc::UnboundedSender 发送消息给 网络future 从而发送给前端
worldsender: mpsc::UnboundedSender, 跟world actor 通信接口
pub enum ActorMessage {
synmsgwaitrep {
//同步等待回复
//需要发送到别处等到别处返回结果，类似于同步操作，只是异步执行的 //oneshot spsc
respond_to: crate::synMsgWaitRep, //同步消息
},
wtc_userchann {
respond_to: crate::userChan_WTC, //
},
wtc_msg(sendMsgAndType),
wtc_forwardmsg(sendMsgAndType), //直接转发 data
ctw_msg(sendMsgAndType),
ctc_nettologic_msg(sendMsgAndType), //网络消息 to logic
ctc_logictonet_msg(sendMsgAndType), //logic to net send
ctc_signal_event(signalType),
ctw_signal_event(signalType),
wtc_signal_event(signalType),
wtc_getChan_msg(userChannChann),
}
pub struct MyUserActor {
connid: ConnectID,
userid: UserID,
username: String,
guildid: GuildID,
userstate: Arc<AtomicU8>,
receiver: mpsc::UnboundedReceiver<ActorMessage>,
sendclient: mpsc::UnboundedSender<VU8>,
worldsender: mpsc::UnboundedSender<ActorMessage>,
msgmask: u32,
lasttime: [u32; ChatChannel_Num],
}
world actor
mpscrecv: mpsc::UnboundedReceiver, 接收ActorMessage logic future
chanchan: mpsc::UnboundedReceiver, 接受 ActorMessage2 logic future
pub enum ActorMessage2 {
synmsgwaitrep {
//同步等待回复
//需要发送到别处等到别处返回结果，类似于同步操作，只是异步执行的 //oneshot spsc
respond_to: crate::synMsgWaitRep2, //同步消息
},
ctw_userhann {
respond_to: crate::userChan_CTW, //同步消息
},
}
pub struct userSendChanActorMessage {
pub(crate) chanchan: Option<mpsc::UnboundedSender<ActorMessage>>,
pub(crate) username: String,
pub(crate) userguildid: GuildID,
pub(crate) connectid: ConnectID,
pub(crate) chanState: Arc<AtomicU8>, //user 状态
}
pub struct worldActor {
sharestate: Arc<AtomicU8>,
mpscrecv: mpsc::UnboundedReceiver<ActorMessage>,
chanchan: mpsc::UnboundedReceiver<ActorMessage2>,
usermap: HashMap<UserID, userChan_world>,
namemap: HashMap<String, UserID>,
guildmap: HashMap<GuildID, HashSet<UserID>>,
maxonlinerole: u32,
}
async fn run(mut self) {
// let logic_handle = self.handle_logic(recv);
loop {
tokio::select! {
recvmsg= self.mpscrecv.recv()=> {
if let Some(actmsg) = recvmsg {
self.handle_logic(actmsg).await ;
}
}
recvmsgchan= self.chanchan.recv()=>{
if let Some(actmsg) = recvmsgchan {
self.handle_logic2(actmsg).await ;
}
}
_=tokio::time::sleep(Duration::from_millis(1000*8)) =>{
}
}
} //end loop
}
同步的方式的异步 go 很简单， rust go 上多一点点
go
rust
网络跟逻辑分开，这样 挤号，只需要把 logic future 里 sendclient mpsc 更新， 把网络 to logic mpsc 更新 及一些 状态重置下 即可，无需重新加载现有useractor 里的信息
类试单点登录 对于聊天服务器来说 ，只需要 角色进入后，由logic服 ase 对称加密(密钥及盐，logic 服 chat 服 共享/配置，共享方式自行决定）或 非对称(ECC) 等都可以，加密的token 由前端发送 给chat 服，chat 解密 得到 相应信息 并验证有效性 参考加解密验证用户的合法性
3:测试
前端简单用go 写了个
var origin = "http://192.168.1.32:8080"
var url = "wss://192.168.1.32:8080/websocket"
func GetProtoMsgID(data []byte) uint32 {
var sMsgID uint16 = uint16(uint8(data[3] & 0x7f))
if (uint8(data[3]) & 0x80) > 0 {
sMsgID += (uint16(data[4]) & 0x7f) << 7
}
return uint32(sMsgID)
}
func sendMsg(ws *websocket.Conn,pb proto.Message) {
if ws != nil {
if data, err2 := proto.Marshal(pb); err2 != nil {
log.Printf("SendMessage pb=%v err2=%v \n", pb, err2)
} else {
if err4 := websocket.Message.Send(ws, data); err4 != nil {
log.Printf("send error =%v \n", err4)
}
}
}
}
func doLogicMsg(data []byte) {
msgId := GetProtoMsgID(data)
fmt.Printf("msgid=%v",msgId)
switch msgId {
case uint32(chatproto.CHATMSG_CHC_Login_Rep):
{
loginReq := &chatproto.ChatMessageLoginRep{
}
if err := proto.Unmarshal(data, loginReq); err != nil {
} else {
fmt.Printf("CHATMSG_CHC_Login_Rep =%v \n",loginReq.Res)
}
}
case uint32(chatproto.CHATMSG_CCH_Chat_Rep):
{
chatrep := &chatproto.ChatMessageChatRep{
}
if err := proto.Unmarshal(data, chatrep); err != nil {
} else {
fmt.Printf("CHATMSG_CCH_Chat_Rep =%v \n",chatrep.Res)
}
}
case uint32(chatproto.CHATMSG_CHC_Notify_Chat):
{
chatmsg := &chatproto.ChatMessageNotifyChat{
}
if err := proto.Unmarshal(data, chatmsg); err != nil {
} else {
fmt.Printf("CHATMSG_CHC_Notify_Chat =%v fromuserid=%v text=%v \n",chatmsg.Chattype,chatmsg.Senderid,chatmsg.Strcontext)
}
}
}
}
func getTimestamp() uint32 {
return uint32(time.Now().UTC().Unix());
}
func main(){
//if os.Args[0]
userid := getTimestamp()
guildid := uint32(0)
if len(os.Args) > 1 {
if s,e := strconv.Atoi(os.Args[1]);e ==nil {
userid = uint32(s)
}
}
if len(os.Args) > 2 {
if s,e := strconv.Atoi(os.Args[2]);e ==nil {
guildid = uint32(s)
}
}
ws, err := websocket.Dial(url, "", origin)
if err != nil {
log.Fatal(err)
}
fmt.Printf("userid=%v guild=%v \n",userid,guildid)
{
msg := new(chatproto.ChatMessageLoginReq)
msg.Msghead = &chatproto.ChatMessageHead{
uint32(chatproto.CHATMSG_CCH_Login_Req), 1}
msg.Userid = userid
msg.Username = "name_"+strconv.Itoa(int(userid))
msg.Guildid = guildid
msg.Tokenmd5 = "md5"
msg.Tokenstr = "Tokenstr"
sendMsg(ws, msg)
}
disflag := false
{
go func() {
for{
buf := make([]byte, 1024*4)
err := websocket.Message.Receive(ws, &buf)
if err != nil {
//log.Printf("websocket.Message.Receive err=%v ---%s\n", err,self.getAccName())
disflag = true
return
}
if len(buf) >= 4 {
doLogicMsg(buf)
//self.msgQue.PostUserMessage(&ReceiveNetMsg{buf})
} else {
log.Printf("[error]recv data=%v \n", buf)
return
}
}
}()
}
time.Sleep(time.Second*3)
//pub enum ChatChannel{
// ChatChannel_NONE=0,
// ChatChannel_NORMAL,
// ChatChannel_GUILD,
// ChatChannel_WORLD,
// ChatChannel_ALL,
//}
{
sendcount := uint32(1)
num := uint32(0)
msg := new(chatproto.ChatMessageChatReq)
msg.Msghead = &chatproto.ChatMessageHead{
uint32(chatproto.CHATMSG_CCH_Chat_Req), 1}
msg.Chattype = 1
msg.Context ="normal chat "+ strconv.Itoa(int(num))
for {
if disflag {
//脏数据
break
}
sendMsg(ws, msg)
time.Sleep(time.Second*10)
num++
m := num % 3 +1
msg.Chattype = uint32(m)
msg.Context ="normal chat "+ strconv.Itoa(int(sendcount))
fmt.Printf("[%v][%v] send chattype=%v \n",sendcount,getTimestamp(),msg.Chattype)
sendcount++
//if m == 3 {
// time.Sleep(time.Second*10)
//}
}
}
ws.Close()//关闭连接
fmt.Printf("client exit\n")
}
相互挤号测试
4:DEMO工程 后续完善了如有需要再上传(当前只能说基本上跑起来)
如果觉得有用，麻烦点个赞，加个收藏
