Timer e promemoria degli attori
Gli attori possono pianificare il relativo lavoro periodico registrando timer o promemoria. Questo articolo illustra come usare timer e promemoria e ne spiega le differenze.
Timer degli attori
I timer degli attori forniscono un wrapper semplice intorno al timer .NET o Java per garantire che i metodi di callback rispettino le garanzie di concorrenza basata su turni offerte dal runtime di Actors.
Per eseguire e annullare la registrazione dei timer, gli attori possono usare i metodi RegisterTimer(C#) o registerTimer(Java) e UnregisterTimer(C#) o unregisterTimer(Java) nella propria classe base. L'esempio seguente illustra l'uso delle API di timer, che sono molto simili al timer .NET o al timer Java. In questo esempio, quando il timer è in scadenza, il runtime di Actors chiama il metodo MoveObject(C#) o moveObject(Java). Si garantisce che il metodo rispetti la concorrenza basata su turni. Ciò significa che nessun altro metodo di attori o callback di timer/promemoria sarà in azione fino al completamento dell'esecuzione del callback.
class VisualObjectActor : Actor, IVisualObject
{
private IActorTimer _updateTimer;
public VisualObjectActor(ActorService actorService, ActorId actorId)
: base(actorService, actorId)
{
}
protected override Task OnActivateAsync()
{
...
_updateTimer = RegisterTimer(
MoveObject, // Callback method
null, // Parameter to pass to the callback method
TimeSpan.FromMilliseconds(15), // Amount of time to delay before the callback is invoked
TimeSpan.FromMilliseconds(15)); // Time interval between invocations of the callback method
return base.OnActivateAsync();
}
protected override Task OnDeactivateAsync()
{
if (_updateTimer != null)
{
UnregisterTimer(_updateTimer);
}
return base.OnDeactivateAsync();
}
private Task MoveObject(object state)
{
...
return Task.FromResult(true);
}
}
public class VisualObjectActorImpl extends FabricActor implements VisualObjectActor
{
private ActorTimer updateTimer;
public VisualObjectActorImpl(FabricActorService actorService, ActorId actorId)
{
super(actorService, actorId);
}
@Override
protected CompletableFuture onActivateAsync()
{
...
return this.stateManager()
.getOrAddStateAsync(
stateName,
VisualObject.createRandom(
this.getId().toString(),
new Random(this.getId().toString().hashCode())))
.thenApply((r) -> {
this.registerTimer(
(o) -> this.moveObject(o), // Callback method
"moveObject",
null, // Parameter to pass to the callback method
Duration.ofMillis(10), // Amount of time to delay before the callback is invoked
Duration.ofMillis(timerIntervalInMilliSeconds)); // Time interval between invocations of the callback method
return null;
});
}
@Override
protected CompletableFuture onDeactivateAsync()
{
if (updateTimer != null)
{
unregisterTimer(updateTimer);
}
return super.onDeactivateAsync();
}
private CompletableFuture moveObject(Object state)
{
...
return this.stateManager().getStateAsync(this.stateName).thenCompose(v -> {
VisualObject v1 = (VisualObject)v;
v1.move();
return (CompletableFuture<?>)this.stateManager().setStateAsync(stateName, v1).
thenApply(r -> {
...
return null;});
});
}
}
Il periodo successivo del timer inizia dopo il completamento del callback. Pertanto, il timer viene arrestato mentre il callback è in esecuzione e viene avviato quando il callback è completato.
Il runtime di Actors salva le modifiche apportate alla gestione stati dell'attore al termine del callback. Se si verifica un errore durante il salvataggio dello stato, viene disattivato l'oggetto attore e viene attivata una nuova istanza.
A differenza dei promemoria, i timer non possono essere aggiornati. Se RegisterTimer viene chiamato di nuovo, verrà registrato un nuovo timer.
Tutti i timer vengono arrestati quando l'attore viene disattivato come parte di garbage collection. In seguito, non viene richiamato nessun callback di timer. Inoltre, il runtime di Actors non mantiene alcuna informazione sui timer in esecuzione prima della disattivazione. È responsabilità dell'attore registrare gli eventuali timer che saranno necessari quando verrà riattivato in futuro. Per ulteriori informazioni, vedere la sezione sulla garbage collection degli attori.
Promemoria degli attori
I promemoria sono un meccanismo per attivare i callback persistenti su un attore in base a orari specificati. La loro funzionalità è simile a quella dei timer. Tuttavia, a differenza dei timer, i promemoria vengono attivati in qualsiasi circostanza finché l'attore non ne annulla la registrazione in modo esplicito o finché l'attore non viene eliminato in modo esplicito. In particolare, i promemoria vengono attivati anche in caso di failover e disattivazione dell'attore perché il runtime di Actors rende persistenti le informazioni sui promemoria dell'attore tramite il provider di stato dell'attore. A differenza dei timer, i promemoria esistenti possono essere aggiornati chiamando di nuovo il metodo di registrazione (RegisterReminderAsync) usando lo stesso reminderName.
Nota
L’affidabilità dei promemoria è collegata alle garanzie di affidabilità degli stati fornite dal provider di stato dell'attore. Questo significa che per gli attori in cui la persistenza dello stato è impostata su None, non verrà attivato alcun promemoria dopo un failover.
Per registrare un promemoria, un attore chiama il metodo RegisterReminderAsync fornito nella classe base, come illustrato nell'esempio seguente.
protected override async Task OnActivateAsync()
{
string reminderName = "Pay cell phone bill";
int amountInDollars = 100;
IActorReminder reminderRegistration = await this.RegisterReminderAsync(
reminderName,
BitConverter.GetBytes(amountInDollars),
TimeSpan.FromDays(3), //The amount of time to delay before firing the reminder
TimeSpan.FromDays(1)); //The time interval between firing of reminders
}
@Override
protected CompletableFuture onActivateAsync()
{
String reminderName = "Pay cell phone bill";
int amountInDollars = 100;
ActorReminder reminderRegistration = this.registerReminderAsync(
reminderName,
state,
dueTime, //The amount of time to delay before firing the reminder
period); //The time interval between firing of reminders
}
In questo esempio "Pay cell phone bill" è il nome del promemoria. Questa è una stringa usata dall'attore per identificare in modo univoco un promemoria. BitConverter.GetBytes(amountInDollars)(C#) è il contesto associato al promemoria. Questo contesto verrà passato all'attore come argomento per il callback di promemoria, ad esempio IRemindable.ReceiveReminderAsync(C#) o Remindable.receiveReminderAsync(Java).
Gli attori che usano i promemoria devono implementare l'interfaccia IRemindable , come illustrato nell'esempio seguente.
public class ToDoListActor : Actor, IToDoListActor, IRemindable
{
public ToDoListActor(ActorService actorService, ActorId actorId)
: base(actorService, actorId)
{
}
public Task ReceiveReminderAsync(string reminderName, byte[] context, TimeSpan dueTime, TimeSpan period)
{
if (reminderName.Equals("Pay cell phone bill"))
{
int amountToPay = BitConverter.ToInt32(context, 0);
System.Console.WriteLine("Please pay your cell phone bill of ${0}!", amountToPay);
}
return Task.FromResult(true);
}
}
public class ToDoListActorImpl extends FabricActor implements ToDoListActor, Remindable
{
public ToDoListActor(FabricActorService actorService, ActorId actorId)
{
super(actorService, actorId);
}
public CompletableFuture receiveReminderAsync(String reminderName, byte[] context, Duration dueTime, Duration period)
{
if (reminderName.equals("Pay cell phone bill"))
{
int amountToPay = ByteBuffer.wrap(context).getInt();
System.out.println("Please pay your cell phone bill of " + amountToPay);
}
return CompletableFuture.completedFuture(true);
}
Quando viene attivato un promemoria, il runtime di Reliable Actors richiama il metodo ReceiveReminderAsync(C#) o receiveReminderAsync(Java) sull'Actor. Un attore può registrare più promemoria e il metodo ReceiveReminderAsync(C#) o receiveReminderAsync(Java) viene richiamato ogni volta che tali promemoria vengono attivati. L'attore può usare il nome del promemoria che viene passato al metodo ReceiveReminderAsync(C#) o receiveReminderAsync(Java) per identificare il promemoria attivato.
Il runtime di Actors salva lo stato dell'attore al termine della chiamata a ReceiveReminderAsync(C#) o receiveReminderAsync(Java). Se si verifica un errore durante il salvataggio dello stato, viene disattivato l'oggetto attore e viene attivata una nuova istanza.
Per annullare la registrazione di un promemoria, un attore chiama il metodo UnregisterReminderAsync(C#) o unregisterReminderAsync(Java), come illustrato nell'esempio seguente.
IActorReminder reminder = GetReminder("Pay cell phone bill");
Task reminderUnregistration = await UnregisterReminderAsync(reminder);
ActorReminder reminder = getReminder("Pay cell phone bill");
CompletableFuture reminderUnregistration = unregisterReminderAsync(reminder);
Come mostrato in precedenza, il metodo UnregisterReminderAsync(C#) o unregisterReminderAsync(Java) accetta un'interfaccia IActorReminder(C#) o ActorReminder(Java). La classe base dell'attore supporta un metodo GetReminder(C#) o getReminder(Java) che può essere usato per recuperare l'interfaccia IActorReminder(C#) o ActorReminder(Java) passando il nome del promemoria. Questo metodo è utile perché l'attore non deve rendere persistente l'interfaccia IActorReminder(C#) o ActorReminder(Java) restituita dalla chiamata al metodo RegisterReminder(C#) o registerReminder(Java).
Passaggi successivi
Acquisire informazioni sugli eventi e sulla rientranza di Reliable Actor: