初學Actor Model - Akka.Net

此篇文章基本上是Akka.Net的基礎教學的筆記。

• • 什麼是Actor？
    • Actors如何互相溝通？
    • Actor可以做什麼？
    • 什麼是一個ActorSystem
    • 安裝Akka.Net NuGet
    • 建立ActorSystem
    • 建立一個Actor
  • Props和IActorRef’s
    • 什麼是Props？
    • 如何建立Props
    • 什麼是IActorRef
  • 子Actor，Actor階層及監管
    • Actor階層中如何監管？
    • 何時需要監管？
    • 監管規則
    • 監管策略
    • 重點是什麼？隔離！
  • 使用ActorSelection依位址尋找特定Actor
  • Actor的生命週期
  • 使用ReceiveActor來更聰明的處理訊息
  • 使用BecomeStacked和UnbecomeStacked在執行時變更Actor的行為
    • 什麼是Switchable behavior？
    • 如何實作

什麼是Actor？

Actor是一個系統中對參與者的模擬。它可能是一個實體，一個類別，可以做一些事情，及互相溝通。

Actors如何互相溝通？

Actors透過訊息互相溝通，任何POCO都可以是訊息，字串、整數、類別、或實作了一個介面的物件。

//this is a message!
public class SomeMessage
{
    public int SomeValue {get; set}
}

傳送訊息：

//send a string to an actor
someActorRef.Tell("this is a message too!");

Actor可以做什麼？

除了處理收到的訊息外，一個actor還可以：
* 建立另一個actor
* 傳送訊息給另一個actor
* 變更它自己的行為，並處理不同的訊息(相對於原先的行為的訊息)

什麼是一個ActorSystem

一個ActorSystem是對Akka.NET framework內部系統的一個參考，所有的actor都生存在其中，你也需要以它來建立你的actor。

安裝Akka.Net NuGet

Install-Package Akka

建立ActorSystem

var system = ActorSystem.Create("MyActorSystem");

建立一個Actor

var writerActor = system.ActorOf(
    Props.Create(
        () => new WriterActor()),
        "writerActor");

或是使用泛型的方式：

var writerActor = system.ActorOf(
    Props.Create<WriterActor>(), "writerActor");

Props和IActorRef’s

什麼是Props？

Props是一個封裝了所有需要建立實體actor的資訊的設定類別。

如何建立Props

1. 使用lambda語法：

Props props = Props.Create(() => new MyActor(..), "...");

1. 使用泛型語法：

Props props = Props.Create<MyActor>();

什麼是IActorRef

IActorRef代表對一個actor的參考。目的是支援透過ActorSystem傳送訊息給一個actor。

子Actor，Actor階層及監管

建立最上層的actors：

// create the top level actors from above diagram
IActorRef a1 = MyActorSystem.ActorOf(Props.Create<BasicActor>(), "a1");
IActorRef a2 = MyActorSystem.ActorOf(Props.Create<BasicActor>(), "a2");

建立a2下的子actors：

// create the children of actor a2
// this is inside actor a2
IActorRef b1 = Context.ActorOf(Props.Create<BasicActor>(), "b1");
IActorRef b2 = Context.ActorOf(Props.Create<BasicActor>(), "b2");

Actor階層中如何監管？

每個actor會監管其子actor，且僅止於其子actor，如上面的階層圖，a2僅監管b1及b2。

何時需要監管？

發生錯誤時！
當一個子actor發生未處理的例外且要掛掉時，它會尋求它的父actor的幫忙。它會傳送一個Failure類別的訊息，並由父actor決定如何處理。

監管規則

當父actor收到來自其子actor的錯誤訊息，它可以決定以下列方式處理：
* 重啟子actor(預設行為)
* 停止子actor
* 上報錯誤(且停止自己的動作)

監管策略

有兩個內建的策略型態：
* 一對一：父actor發佈的命令僅針對發生錯誤的子actor
* 一對全部：父actor發佈的命令不僅只針對發生錯誤的子actor，而是其所有的子actor

重點是什麼？隔離！

如下圖所示：

我們切分工作，把可能會發生錯誤的地方放在某一節點上，這讓潛在的錯誤被隔離，系統不會因為一個節點的錯誤而崩潰！

使用ActorSelection依位址尋找特定Actor

var selection = Context.ActorSelection("/path/to/actorName");
selection.Tell(message);

或使用ActorOf：

class FooActor : UntypedActor {}
Props props = Props.Create<FooActor>();

// the ActorPath for myFooActor is "/user/barBazActor"
// NOT "/user/myFooActor" or "/user/FooActor"
IActorRef myFooActor = MyActorSystem.ActorOf(props, "barBazActor");

// if you don't specify a name on creation as below, the system will
// auto generate a name for you, so the actor path will
// be something like "/user/$a"
IActorRef myFooActor = MyActorSystem.ActorOf(props);

也可參考：When Should I Use Actor Selection?

Actor的生命週期

使用ReceiveActor來更聰明的處理訊息

public class StringActor : ReceiveActor
{
    public StringActor()
    {
        Receive<string>(
            s => s.StartsWith("AkkaDotNet"), 
            s =>{ /* handle string */ });

        Receive<string>(
            s => s.StartsWith("AkkaDotNetSuccess"), 
            s =>{/* handle string*/});
    }
}

使用BecomeStacked和UnbecomeStacked在執行時變更Actor的行為

public class UserActor : ReceiveActor {
    private readonly string _userId;
    private readonly string _chatRoomId;

    public UserActor(string userId, string chatRoomId) {
        _userId = userId;
        _chatRoomId = chatRoomId;

        // start with the Authenticating behavior
        Authenticating();
    }

    protected override void PreStart() {
        // start the authentication process for this user
        Context.ActorSelection("/user/authenticator/")
            .Tell(new AuthenticatePlease(_userId));
    }

    private void Authenticating() {
        Receive<AuthenticationSuccess>(auth => {
            Become(Authenticated); //switch behavior to Authenticated
        });
        Receive<AuthenticationFailure>(auth => {
            Become(Unauthenticated); //switch behavior to Unauthenticated
        });
        Receive<IncomingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // can't accept message yet - not auth'd
            });
        Receive<OutgoingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // can't send message yet - not auth'd
            });
    }

    private void Unauthenticated() {
        //switch to Authenticating
        Receive<RetryAuthentication>(retry => Become(Authenticating));
        Receive<IncomingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // have to reject message - auth failed
            });
        Receive<OutgoingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // have to reject message - auth failed
            });
    }

    private void Authenticated() {
        Receive<IncomingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // print message for user
            });
        Receive<OutgoingMessage>(inc => inc.ChatRoomId == _chatRoomId,
            inc => {
                // send message to chatroom
            });
    }
}

什麼是Switchable behavior？

在Actor Model中，一個Actor的核心屬性是它可以在訊息的處理過程中變更自己的行為。
這個特性讓Actor可以實作有限狀態機，或根據所收到的訊息變更處理的方式。

如何實作

• 堆疊式

  • BecomeStacked
  • UnbecomeStacked

• 直接變更

  • Become

Written with StackEdit.