Reliable Actors reentrancy

  • Článek

Modul runtime Reliable Actors ve výchozím nastavení umožňuje opakování logického volání na základě kontextu. To umožňuje, aby se aktéři znovu zasílali, pokud jsou ve stejném řetězci kontextu volání. Například objekt Actor A odešle zprávu hereci B, který odešle zprávu herci C. Pokud objekt Actor C při zpracování zprávy volá actor A, zpráva se znovu odešle, takže bude povolená. Všechny ostatní zprávy, které jsou součástí jiného kontextu volání, budou v objektu Actor A blokovány, dokud se zpracování nedokončí.

Pro opětovné zaentrancy objektu actor jsou ve výčtu ActorReentrancyMode k dispozici dvě možnosti:

  • LogicalCallContext (výchozí chování)
  • Disallowed – zakáže opětovné zaentrování.
public enum ActorReentrancyMode
{
    LogicalCallContext = 1,
    Disallowed = 2
}

public enum ActorReentrancyMode
{
    LogicalCallContext(1),
    Disallowed(2)
}

Opětovné zaentrování je možné nakonfigurovat v ActorServicenastavení během registrace. Nastavení platí pro všechny instance objektu actor vytvořené ve službě actor.

Následující příklad ukazuje službu actor, která nastaví režim opětovného zaentrancy na ActorReentrancyMode.Disallowed. Pokud v tomto případě objekt actor odešle zprávu s opakovaným odesláním jinému objektu, vyvolá se výjimka typu FabricException .

static class Program
{
    static void Main()
    {
        try
        {
            ActorRuntime.RegisterActorAsync<Actor1>(
                (context, actorType) => new ActorService(
                    context,
                    actorType, () => new Actor1(),
                    settings: new ActorServiceSettings()
                    {
                        ActorConcurrencySettings = new ActorConcurrencySettings()
                        {
                            ReentrancyMode = ActorReentrancyMode.Disallowed
                        }
                    }))
                .GetAwaiter().GetResult();

            Thread.Sleep(Timeout.Infinite);
        }
        catch (Exception e)
        {
            ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
            throw;
        }
    }
}

static class Program
{
    static void Main()
    {
        try
        {
            ActorConcurrencySettings actorConcurrencySettings = new ActorConcurrencySettings();
            actorConcurrencySettings.setReentrancyMode(ActorReentrancyMode.Disallowed);

            ActorServiceSettings actorServiceSettings = new ActorServiceSettings();
            actorServiceSettings.setActorConcurrencySettings(actorConcurrencySettings);

            ActorRuntime.registerActorAsync(
                Actor1.getClass(),
                (context, actorType) -> new FabricActorService(
                    context,
                    actorType, () -> new Actor1(),
                    null,
                    stateProvider,
                    actorServiceSettings, timeout);

            Thread.sleep(Long.MAX_VALUE);
        }
        catch (Exception e)
        {
            throw e;
        }
    }
}

Další kroky