Ciclo di vita degli attori, Garbage Collection automatica ed eliminazione manualeActor lifecycle, automatic garbage collection, and manual delete

Un attore viene attivato la prima volta che viene effettuata una chiamata a uno dei suoi metodi.An actor is activated the first time a call is made to any of its methods. Un attore viene disattivato (tramite Garbage Collection del runtime di Actors) se rimane inutilizzato per un periodo di tempo configurabile.An actor is deactivated (garbage collected by the Actors runtime) if it is not used for a configurable period of time. Un attore e il relativo stato possono essere eliminati manualmente in qualsiasi momento.An actor and its state can also be deleted manually at any time.

Attivazione di un attoreActor activation

Quando un attore viene attivato, si verifica quanto segue:When an actor is activated, the following occurs:

  • Quando viene effettuata una chiamata per un attore che non è ancora attivo, viene creato un nuovo attore.When a call comes for an actor and one is not already active, a new actor is created.
  • Viene caricato lo stato dell'attore, se viene mantenuto.The actor's state is loaded if it's maintaining state.
  • Viene chiamato il metodo OnActivateAsync (C#) o onActivateAsync (Java), che può essere sottoposto a override nell'implementazione dell'attore.The OnActivateAsync (C#) or onActivateAsync (Java) method (which can be overridden in the actor implementation) is called.
  • A questo punto l'attore è considerato attivo.The actor is now considered active.

Disattivazione di un attoreActor deactivation

Quando un attore viene disattivato, si verifica quanto segue:When an actor is deactivated, the following occurs:

  • Quando un attore rimane inutilizzato per un determinato periodo di tempo, viene rimosso dalla tabella degli attori attivi.When an actor is not used for some period of time, it is removed from the Active Actors table.
  • Viene chiamato il metodo OnDeactivateAsync (C#) o onDeactivateAsync (Java), che può essere sottoposto a override nell'implementazione dell'attore.The OnDeactivateAsync (C#) or onDeactivateAsync (Java) method (which can be overridden in the actor implementation) is called. Ciò elimina tutti i timer dell'attore.This clears all the timers for the actor. Le operazioni dell'attore come le modifiche di stato non devono essere chiamate da questo metodo.Actor operations like state changes should not be called from this method.

Suggerimento

Il runtime di Fabric Actors emette alcuni eventi relativi all'attivazione e alla disattivazione.The Fabric Actors runtime emits some events related to actor activation and deactivation. che sono utili per la diagnostica e il monitoraggio delle prestazioni.They are useful in diagnostics and performance monitoring.

Garbage Collection degli attoriActor garbage collection

Quando un attore viene disattivato, i riferimenti all'oggetto corrispondente vengono rilasciati e l'attore può essere sottoposto a Garbage Collection dal garbage collector di Common Language Runtime (CLR) o di Java Virtual Machine (JVM).When an actor is deactivated, references to the actor object are released and it can be garbage collected normally by the common language runtime (CLR) or java virtual machine (JVM) garbage collector. L'operazione di Garbage Collection pulisce solo l'oggetto attore, ma non rimuove lo stato archiviato nel gestore di stato dell'attore.Garbage collection only cleans up the actor object; it does not remove state stored in the actor's State Manager. Alla successiva attivazione dell'attore viene creato un nuovo oggetto attore e viene ripristinato il relativo stato.The next time the actor is activated, a new actor object is created and its state is restored.

Quali criteri determinano l'uso degli attori ai fini della disattivazione e dell'operazione di Garbage Collection?What counts as “being used” for the purpose of deactivation and garbage collection?

  • Ricezione di una chiamataReceiving a call
  • IRemindable.ReceiveReminderAsync (applicabile solo se l'attore usa promemoria)IRemindable.ReceiveReminderAsync method being invoked (applicable only if the actor uses reminders)

Nota

Se l'attore usa i timer e viene eseguito il callback di timer, questa azione non viene considerata per determinare l'uso dell'attore.if the actor uses timers and its timer callback is invoked, it does not count as "being used".

Prima di approfondire i concetti relativi alla disattivazione, è importante definire i termini seguenti:Before we go into the details of deactivation, it is important to define the following terms:

  • Intervallo di analisi.Scan interval. Intervallo di tempo in cui il runtime di Actors esegue l'analisi della tabella degli attori attivi per identificare quelli che possono essere disattivati e sottoposti a Garbage Collection.This is the interval at which the Actors runtime scans its Active Actors table for actors that can be deactivated and garbage collected. Il valore predefinito è 1 minuto.The default value for this is 1 minute.
  • Timeout di inattività.Idle timeout. Periodo di tempo in cui un attore deve rimanere inutilizzato (inattivo) prima di poter essere disattivato e sottoposto a Garbage Collection.This is the amount of time that an actor needs to remain unused (idle) before it can be deactivated and garbage collected. Il valore predefinito è 60 minuti.The default value for this is 60 minutes.

Non è in genere necessario modificare questi valori predefiniti.Typically, you do not need to change these defaults. Se necessario, però, questi intervalli possono essere modificati tramite ActorServiceSettings durante la registrazione del servizio Actor:However, if necessary, these intervals can be changed through ActorServiceSettings when registering your Actor Service:

public class Program
{
    public static void Main(string[] args)
    {
        ActorRuntime.RegisterActorAsync<MyActor>((context, actorType) =>
                new ActorService(context, actorType,
                    settings:
                        new ActorServiceSettings()
                        {
                            ActorGarbageCollectionSettings =
                                new ActorGarbageCollectionSettings(10, 2)
                        }))
            .GetAwaiter()
            .GetResult();
    }
}
public class Program
{
    public static void main(String[] args)
    {
        ActorRuntime.registerActorAsync(
                MyActor.class,
                (context, actorTypeInfo) -> new FabricActorService(context, actorTypeInfo),
                timeout);
    }
}

Per ogni attore attivo, il runtime di Actors tiene traccia del periodo di inattività.For each active actor, the actor runtime keeps track of the amount of time that it has been idle (i.e. not used). Il runtime di Actors controlla ogni attore in base alla frequenza definita da ScanIntervalInSeconds per verificare se può essere sottoposto a Garbage Collection e determina se l'attore è rimasto inattivo per il numero di secondi definito da IdleTimeoutInSeconds.The actor runtime checks each of the actors every ScanIntervalInSeconds to see if it can be garbage collected and collects it if it has been idle for IdleTimeoutInSeconds.

Ogni volta che un attore viene usato, il periodo di inattività viene reimpostato su 0.Anytime an actor is used, its idle time is reset to 0. A questo punto, l'attore può essere sottoposto a Garbage Collection solo se rimane nuovamente inattivo per il numero di secondi definito da IdleTimeoutInSeconds.After this, the actor can be garbage collected only if it again remains idle for IdleTimeoutInSeconds. È importante ricordare che l'uso di un attore è determinato in base all'esecuzione di un metodo di interfaccia o di un callback di promemoria dell'attore.Recall that an actor is considered to have been used if either an actor interface method or an actor reminder callback is executed. L'uso di un attore non è determinato in base all'esecuzione del callback dei timer.An actor is not considered to have been used if its timer callback is executed.

Il diagramma seguente mostra il ciclo di vita di un unico attore per illustrare questi concetti.The following diagram shows the lifecycle of a single actor to illustrate these concepts.

Esempio del tempo di inattività

Nell'esempio viene illustrato l'impatto delle chiamate ai metodi degli attori, dei promemoria e dei timer sulla durata dell'attore.The example shows the impact of actor method calls, reminders, and timers on the lifetime of this actor. Per questo esempio è opportuno evidenziare i punti seguenti:The following points about the example are worth mentioning:

  • ScanInterval e IdleTimeout sono impostati rispettivamente su 5 e 10.ScanInterval and IdleTimeout are set to 5 and 10 respectively. (Unità non è rilevante in questo caso, poiché l’obiettivo è solo di illustrare il concetto.)(Units do not matter here, since our purpose is only to illustrate the concept.)
  • L'analisi degli attori da sottoporre a Garbage Collection viene eseguita in T=0,5,10,15,20,25, come definito dall’intervallo di analisi di 5.The scan for actors to be garbage collected happens at T=0,5,10,15,20,25, as defined by the scan interval of 5.
  • Viene attivato un timer periodico in T=4,8,12,16,20,24 e ne viene eseguito il callback.A periodic timer fires at T=4,8,12,16,20,24, and its callback executes. Questo non influisce sul tempo di inattività dell'attore.It does not impact the idle time of the actor.
  • Una chiamata a un metodo dell'attore in T=7 reimposta il tempo di inattività su 0 ritardando l'operazione di Garbage Collection dell'attore.An actor method call at T=7 resets the idle time to 0 and delays the garbage collection of the actor.
  • Un callback di promemoria dell'attore eseguito in T=14 ritarda ulteriormente l'operazione di Garbage Collection dell'attore.An actor reminder callback executes at T=14 and further delays the garbage collection of the actor.
  • Durante l'analisi di Garbage Collection in T=25, il tempo di inattività dell'attore supera infine il timeout di inattività di 10 e l'attore viene sottoposto a Garbage Collection.During the garbage collection scan at T=25, the actor's idle time finally exceeds the idle timeout of 10, and the actor is garbage collected.

Un attore non viene mai sottoposto a Garbage Collection mentre è in esecuzione uno dei relativi metodi, indipendentemente dal tempo impiegato per l'esecuzione di tale metodo.An actor will never be garbage collected while it is executing one of its methods, no matter how much time is spent in executing that method. Come accennato in precedenza, l'esecuzione dei metodi dell'interfaccia dell'attore e dei callback di promemoria impedisce l'operazione di Garbage Collection, reimpostando su 0 il tempo di inattività dell'attore.As mentioned earlier, the execution of actor interface methods and reminder callbacks prevents garbage collection by resetting the actor's idle time to 0. L'esecuzione di callback di timer non ha invece l'effetto di reimpostare su 0 il tempo di inattività.The execution of timer callbacks does not reset the idle time to 0. Tuttavia, l'operazione di Garbage Collection dell'attore viene rinviata finché il callback di timer non ha completato l'esecuzione.However, the garbage collection of the actor is deferred until the timer callback has completed execution.

Eliminazione di attori e del relativo statoDeleting actors and their state

L'operazione di Garbage Collection degli attori disattivati pulisce solo l'oggetto attore, ma non rimuove i dati archiviati in State Manager dell'attore.Garbage collection of deactivated actors only cleans up the actor object, but it does not remove data that is stored in an actor's State Manager. Quando un attore viene riattivato, i suoi dati vengono nuovamente resi disponibili tramite il gestore di stato.When an actor is re-activated, its data is again made available to it through the State Manager. Nei casi in cui gli attori archiviano dati nel gestore di stato e vengono disattivati ma mai riattivati, può essere necessario pulire i relativi dati.In cases where actors store data in State Manager and are deactivated but never re-activated, it may be necessary to clean up their data.

Il servizio Actor fornisce anche una funzione per l'eliminazione di attori da un chiamante remoto:The Actor Service provides a function for deleting actors from a remote caller:

ActorId actorToDelete = new ActorId(id);

IActorService myActorServiceProxy = ActorServiceProxy.Create(
    new Uri("fabric:/MyApp/MyService"), actorToDelete);

await myActorServiceProxy.DeleteActorAsync(actorToDelete, cancellationToken)
ActorId actorToDelete = new ActorId(id);

ActorService myActorServiceProxy = ActorServiceProxy.create(
    new Uri("fabric:/MyApp/MyService"), actorToDelete);

myActorServiceProxy.deleteActorAsync(actorToDelete);

L'eliminazione di un attore produce gli effetti seguenti, a seconda del fatto che l'attore sia attualmente attivo o meno:Deleting an actor has the following effects depending on whether or not the actor is currently active:

  • Attore attivoActive Actor
    • L'attore viene rimosso dall'elenco di attori attivi e viene disattivato.Actor is removed from active actors list and is deactivated.
    • Il suo stato viene eliminato definitivamente.Its state is deleted permanently.
  • Attore inattivoInactive Actor
    • Il suo stato viene eliminato definitivamente.Its state is deleted permanently.

Si noti che un attore non può chiamare un'operazione di eliminazione su se stesso da uno dei suoi metodi attore perché l'attore non può essere eliminato mentre è in esecuzione in un contesto di chiamata attore, in cui il runtime ha ottenuto un blocco per le chiamate dell'attore per applicare l'accesso a thread singolo.Note that an actor cannot call delete on itself from one of its actor methods because the actor cannot be deleted while executing within an actor call context, in which the runtime has obtained a lock around the actor call to enforce single-threaded access.

Passaggi successiviNext steps