Rientranza di Reliable ActorsReliable Actors reentrancy

Per impostazione predefinita, il runtime di Reliable Actors consente la reentrancy basata sul contesto di chiamata logico.The Reliable Actors runtime, by default, allows logical call context-based reentrancy. Ciò consente agli attori di essere rientranti se si trovano nella stessa catena del contesto di chiamata.This allows for actors to be reentrant if they are in the same call context chain. Ad esempio, l'attore A invia un messaggio all'attore B che invia un messaggio all'attore C. Durante l'elaborazione del messaggio, se l'attore C chiama l'attore A, il messaggio è rientrante e sarà quindi consentito.For example, Actor A sends a message to Actor B, who sends a message to Actor C. As part of the message processing, if Actor C calls Actor A, the message is reentrant, so it will be allowed. Tutti gli altri messaggi che fanno parte di un contesto di chiamata diverso verranno bloccati sull'attore A fino al completamento dell'elaborazione.Any other messages that are part of a different call context will be blocked on Actor A until it finishes processing.

Per la reentrancy degli attori sono disponibili due opzioni, definite nell'enumerazione ActorReentrancyMode :There are two options available for actor reentrancy defined in the ActorReentrancyMode enum:

  • LogicalCallContext (comportamento predefinito)LogicalCallContext (default behavior)
  • Disallowed : disabilita la reentrancyDisallowed - disables reentrancy
public enum ActorReentrancyMode
{
    LogicalCallContext = 1,
    Disallowed = 2
}
public enum ActorReentrancyMode
{
    LogicalCallContext(1),
    Disallowed(2)
}

La reentrancy può essere configurata nelle impostazioni di ActorServicedurante la registrazione.Reentrancy can be configured in an ActorService's settings during registration. L'impostazione si applica a tutte le istanze degli attori create nel servizio Actor.The setting applies to all actor instances created in the actor service.

L'esempio seguente illustra un servizio Actor che imposta la modalità di reentrancy su ActorReentrancyMode.Disallowed.The following example shows an actor service that sets the reentrancy mode to ActorReentrancyMode.Disallowed. In questo caso, se un attore invia un messaggio rientrante a un altro attore verrà generata un'eccezione di tipo FabricException .In this case, if an actor sends a reentrant message to another actor, an exception of type FabricException will be thrown.

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

Passaggi successiviNext steps