Sdílet prostřednictvím

Reentrancy Reliable Actors

  • Článek

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

Pro opětovné vytvoření objektu actor definované v výčtu ActorReentrancyMode jsou k dispozici dvě možnosti:

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

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

Při registraci je možné nakonfigurovat přeentrování v ActorServicenastaveních. 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 vytvoření na ActorReentrancyMode.Disallowed. V takovém případě, pokud objekt actor odešle znovu zadat zprávu jinému objektu actor, 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