Reliable Actors reentrancy

De Reliable Actors-runtime staat standaard reentrancy op basis van context voor logische aanroepen toe. Hierdoor kunnen actoren zich opnieuw aanmelden als ze zich in dezelfde oproepcontextketen bevinden. Actor A verzendt bijvoorbeeld een bericht naar Actor B, die een bericht naar Actor C verzendt. Als actor C actor A aanroept als onderdeel van de berichtverwerking, wordt het bericht opnieuw aangevraagd, dus is het toegestaan. Alle andere berichten die deel uitmaken van een andere oproepcontext, worden geblokkeerd op Actor A totdat de verwerking is voltooid.

Er zijn twee opties beschikbaar voor actorreentrancy die is gedefinieerd in de ActorReentrancyMode enum:

• LogicalCallContext (standaardgedrag)
• Disallowed - schakelt reentrancy uit

public enum ActorReentrancyMode
{
    LogicalCallContext = 1,
    Disallowed = 2
}

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

Reentrancy kan worden geconfigureerd in een ActorService's instellingen tijdens de registratie. De instelling is van toepassing op alle actorinstanties die zijn gemaakt in de actorservice.

In het volgende voorbeeld ziet u een actorservice waarmee de reentrancymodus wordt ingesteld op ActorReentrancyMode.Disallowed. In dit geval wordt er een uitzondering van het type FabricException gegenereerd als een actor een reentrant-bericht naar een andere actor verzendt.

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;
        }
    }
}

Volgende stappen

• Meer informatie over reentrancy vindt u in de referentiedocumentatie voor actor-API's)