Read-through, write-through, write-behind NCache

NCache è una cache distribuita in memoria estremamente veloce e scalabile per .NET che memorizza nella cache i dati dell'applicazione per ridurre costosi spostamenti del database. Puoi usare NCache per rimuovere i colli di bottiglia delle prestazioni associati all'archiviazione dei dati e alla scalabilità del database.

Il modo più comune per utilizzare tale cache è consentire all'applicazione di leggere i dati dal database/origine dati e quindi memorizzarli nella cache. Dopodiché, quando l'applicazione aggiorna questi dati nel database, aggiorna anche la cache per garantire che la cache sia sincronizzata con il database.

Per di più, NCache fornisce un altro meccanismo molto potente per leggere e scrivere dati chiamato Data source Provider (Read-through/Write-through/Write-behind) per consentire NCache leggere e scrivere dati dal database.

Ci sono tre modi che puoi usare NCache in tale contesto:

1. Lettura: si sviluppa un gestore Read-through che risiede ed è eseguito su tutti i server cache nel cluster. Quindi, quando l'applicazione recupera i dati dalla cache, NCache chiama il gestore Read-through per andare a leggere questi dati dall'origine dati se tali dati non sono già presenti nella cache.
2. Write-through (sincronizzazione): si sviluppa un gestore di scrittura che risiede ed è anche in esecuzione su tutti i server di cache nel cluster. E, quando la tua applicazione aggiorna i dati nella cache, NCache prima aggiorna la cache e poi chiama il gestore Write-think per aggiornare immediatamente anche il tuo database. Inoltre, la tua applicazione attende fino all'aggiornamento dei dati anche nel database.
3. Write-behind (asincrono): se non vuoi che la tua applicazione attenda finché il gestore Write-through non completa l'aggiornamento dei dati nel database, puoi scegliere l'opzione Write-behind dove NCache aggiorna il tuo database in modo asincrono e la tua applicazione non deve attendere l'aggiornamento del database. Ciò accelera la tua applicazione poiché gli aggiornamenti del database sono generalmente molto più lenti degli aggiornamenti della cache.

Vantaggi di Read-through/Write-through/Write-behind

Ecco alcuni vantaggi derivanti dall'utilizzo delle funzioni Read-through, Write-through e Write-behind NCache.

1. Migliori prestazioni di scrittura con Write-behind: L'aggiornamento del database è in genere molto più lento dell'aggiornamento della cache. Quando usi Write-behind, la tua applicazione aggiorna solo la cache e va avanti mentre NCache aggiorna in modo asincrono il tuo database. Ciò migliora notevolmente le prestazioni dell'applicazione.
2. Maggiore scalabilità del database con la limitazione del write-behind: Se l'applicazione aggiorna il database abbastanza frequentemente, è probabile che si blocchi. Ma se attivi la limitazione con Write-behind, allora NCache mantiene i tuoi dati aggiornati nella cache con la replica e aggiorna lentamente il tuo database. Ciò allevia molta pressione dal tuo database.
3. Aggiorna automaticamente la cache alla scadenza: Se hai sviluppato un gestore Read-through, puoi abilitare l'aggiornamento automatico alla scadenza con NCache. In questo modo, ogni volta che un elemento memorizzato nella cache scade, invece di rimuoverlo dalla cache, NCache chiama il gestore Read-through per ricaricare una nuova copia dall'origine dati.
4. Aggiorna automaticamente la cache in caso di modifiche al database: Se hai sviluppato un gestore Read-through, puoi abilitare l'aggiornamento automatico sulla dipendenza SQL/dipendenza Oracle con NCache. In questo modo, ogni volta che i dati corrispondenti nel database cambiano, invece di rimuovere l'elemento memorizzato nella cache dalla cache, NCache chiama il gestore Read-through per ricaricare una nuova copia dal database.

Caratteristiche principali

Ecco alcuni punti salienti di Read-through, Write-through e Write-behind in NCache.

1. Codice lato server (.NET o Java): Puoi sviluppare i tuoi gestori read-through/write-through con .NET o Java. Esiste un'interfaccia per ogni gestore che sviluppi e distribuisci il tuo codice su tutti i server cache nel cluster. NCache è in grado di richiamarli in fase di runtime quando necessario. Tutti gli handler sviluppati in .NET vengono chiamati nativamente da NCache poiché è sviluppato anche in .NET. Tuttavia, i gestori sviluppati in Java vengono chiamati da NCache attraverso l'interfaccia nativa Java (JNI).
2. Gestori multipli di lettura/scrittura: È possibile sviluppare più gestori Read-through e Write-through e registrarli NCache. In tal caso, hanno tutti un nome e la tua applicazione può richiederne uno qualsiasi specificandone il nome.
3. Gestore di lettura/scrittura predefinito: Se hai più gestori registrati come gestori denominati, allora NCache consente di selezionarne una come opzione predefinita. Questo gestore predefinito viene utilizzato quando l'applicazione non specifica un nome di gestore.
4. Punti salienti della lettura
   1. Lettura forzata: NCache fornisce un'opzione in cui puoi dirgli di utilizzare Read-through anche se l'elemento esiste nella cache (di solito, Read-through viene chiamato solo quando un elemento non viene trovato nella cache). Ciò ti consente di aggiornare questo elemento dal tuo database se ritieni che i dati potrebbero essere cambiati lì.
   2. Ottieni la lettura in blocco: NCache fornisce un'API Bulk Get che consente alla tua applicazione di fornire un elenco di chiavi rispetto alle quali puoi recuperare i dati dalla cache.
   3. Lettura delle strutture dati (contatore, dizionario, elenco, coda, set): NCache fornisce alla tua applicazione la possibilità di recuperare qualsiasi struttura di dati e NCache chiama un gestore Read-through per recuperare questi dati dal database.
5. Punti salienti della scrittura
   1. Rimuovi articolo Write-through: NCache fornisce inoltre alla tua applicazione l'API Remove che ti consente di utilizzare una chiave per rimuovere un elemento dalla cache e quindi dall'origine dati.
   2. Rimozione in blocco di elementi Write-through: NCache fornisce inoltre un'API di rimozione in blocco che consente all'applicazione di fornire un elenco di chiavi da rimuovere dalla cache e dall'origine dati in blocco.
   3. Aggiunta/aggiornamento in blocco Write-through: NCache fornisce un'API di aggiunta/aggiornamento in blocco che consente all'applicazione di fornire un elenco di chiavi e i relativi valori per aggiungere/aggiornare la cache in blocco. Il write-through funziona anche in questa situazione e aggiunge/aggiorna il tuo database/origine dati con questi elementi in blocco.
   4. Write-through di strutture dati (contatore, dizionario, elenco, coda e set): NCache fornisce la possibilità per la tua applicazione di aggiornare qualsiasi struttura di dati e NCache chiama un gestore Write-through per aggiornare il database con le modifiche.
   5. Scrittura asincrona Aggiungi/Aggiorna/Rimuovi Write-through: NCache L'API fornisce Aggiungi/Inserisci/Rimuovi asincrono. Il write-through supporta questa API e viene richiamato ogni volta che l'applicazione effettua tale chiamata API. Qui. Il write-through presuppone che l'applicazione sia in attesa del completamento dell'operazione e il fatto che sia asincrona viene riconosciuto solo a livello di API client.
6. In evidenza scrivi dietro
   1. Coda di operazioni asincrone replicata (alta disponibilità): Write-behind accetta la richiesta del client di aggiornare la cache e aggiorna immediatamente la cache, ma accoda l'aggiornamento del database per l'esecuzione asincrona in un secondo momento. Questa coda viene sempre replicata su più di un server di cache a seconda della topologia di memorizzazione nella cache per garantire che queste operazioni non vadano mai perse nel caso in cui un server di cache si interrompa improvvisamente.
   2. throttling: È possibile specificare un livello di limitazione per le operazioni asincrone Write-behind. Ciò ti consente di distribuirli. Il livello di limitazione predefinito è 500 operazioni/sec.
   3. Modalità write-behind (non batch o batch): La modalità Non batch significa che ogni operazione nella coda Write-behind viene eseguita separatamente, mentre in modalità Batch si raggruppano più operazioni insieme e le si eseguono collettivamente.
   4. Ritardo operazione batch: È possibile specificare un ritardo tra due operazioni in modalità batch. Ciò ti consente di rallentare gli aggiornamenti al database, se lo desideri.
   5. Coda operazioni fallite: Poiché Write-behind esegue tutte le operazioni in modo asincrono quando un'operazione fallisce, NCache può inserirlo nella coda delle operazioni non riuscite in modo che possa essere eseguito nuovamente senza interferire con le nuove operazioni che non sono fallite. È possibile specificare una dimensione massima e uno sfratto.
7. Monitorare i contatori write-through/write-behind: NCache fornisce un ricco set di contatori con cui è possibile monitorare ciò che accade in Write-through/Write-behind. Questi contatori sono disponibili in NCache Monitor, strumento Windows PerfMon, contatori SNMP, Prometheus e Grafana.

Interfaccia codice read-through/write-through

Lo sviluppo di codice per gestori Read-through e Write-through è un processo semplice. Di seguito sono riportati esempi di interfacce per entrambi.

• .NET
• Java

public interface IReadThruProvider
{
	void Init(IDictionary parameters, string cacheId);
	ProviderCacheItem LoadFromSource(string key);
	IDictionary<string, ProviderCacheItem> LoadFromSource(ICollection<string> keys);
	ProviderDataTypeItem<IEnumerable> LoadDataTypeFromSource(string key, DistributedDataType dataType);
	void Dispose();
}

public interface ReadThruProvider extends java.lang.AutoCloseable
{
	void init(java.util.Map<java.lang.String,java.lang.String> parameters, java.lang.String cacheId) throws java.lang.Exception;
	ProviderCacheItem loadFromSource(java.lang.String key) throws java.lang.Exception;
	java.util.Map<java.lang.String,ProviderCacheItem> loadFromSource(java.util.Collection<java.lang.String> keys) throws java.lang.Exception;
	ProviderDataStructureItem loadDataStructureFromSource(java.lang.String key, DistributedDataStructureType distributedDataStructureType) throws java.lang.Exception;
}

• .NET
• Java

public interface IWriteThruProvider
{
	void Init(IDictionary parameters, string cacheId);
	OperationResult WriteToDataSource(WriteOperation operation);
	ICollection<OperationResult> WriteToDataSource(ICollection<WriteOperation> operations);
	ICollection<OperationResult> WriteToDataSource(ICollection<DataTypeWriteOperation> dataTypeWriteOperations);
	void Dispose();
}

public interface WriteThruProvider extends java.lang.AutoCloseable
{
	void init(java.util.Map<java.lang.String,java.lang.String> parameters, java.lang.String cacheId) throws java.lang.Exception;
	OperationResult writeToDataSource(WriteOperation operation) throws java.lang.Exception;
	java.util.Collection<OperationResult> writeToDataSource(java.util.Collection<WriteOperation> operations) throws java.lang.Exception;
	java.util.Collection<OperationResult> writeDataStructureToDataSource(java.util.Collection<DataStructureWriteOperation< dataStructureWriteOperations) throws java.lang.Exception;
}