Sdílet prostřednictvím

Reentrancy spolehlivých aktérů

Modul runtime Reliable Actors ve výchozím nastavení umožňuje znovuvstupování založené na logickém kontextu volání. To umožňuje, aby se aktéři mohli znovu vstupovat, pokud jsou ve stejném kontextovém řetězci volání. Objekt Actor A například odešle zprávu objektu Actor B, který odešle zprávu objektu Actor C. Pokud objekt Actor C zavolá objekt Actor A, je zpráva znovu vstupní a proto bude připuštěna. 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 znovuvstup herce definovaný ve 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)
}

Možnost opětovného vstupu lze nakonfigurovat v nastaveních ActorService 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 reentrance na ActorReentrancyMode.Disallowed. V takovém případě, pokud herec odešle opětovnou zprávu jinému herci, bude vyvolána 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