Verwenden des Read-Through-Cache und des Write-Through-Cache

Angesichts des rasanten Wachstums von Webanwendungen mit hohem Transaktionsvolumen, serviceorientierter Architektur (SOA), Grid-Computing und anderen Serveranwendungen stößt die traditionelle Datenspeicherung oft an ihre Grenzen. Der Grund dafür ist, dass Datenspeichersysteme nicht so einfach skalieren können wie Anwendungsarchitekturen, die durch Hinzufügen weiterer Server erweitert werden können. Dieser Artikel erläutert Caching-Strategien, die in verteilten Systemen eingesetzt werden, anhand von Beispielen aus … NCache.

In solchen Situationen bietet verteilter In-Memory-Cache eine hervorragende Lösung für Datenspeicherengpässe. Er umfasst mehrere Server in einem Cluster, um deren Speicher zu bündeln und den Cache über alle Knoten hinweg synchron zu halten. Dieser Cluster lässt sich, genau wie die Anwendungsserver, unbegrenzt skalieren. Dies reduziert die Belastung des zugrunde liegenden Datenspeichers und beseitigt ihn als Skalierbarkeitsengpass.

Wichtige Erkenntnisse

• Read-Through-Cache Merkmal von NCache Die Anwendung ruft Daten automatisch aus der Datenbank ab, wenn diese von ihr angefordert werden und nicht im Cache vorhanden sind, wodurch der Anwendungscode vereinfacht wird.
• Durchschreibcache Die Datenbank wird synchron aktualisiert, wodurch die Datenkonsistenz zwischen Cache und Datenbank sichergestellt wird. Dies vereinfacht zudem den Anwendungscode. Diese Funktion wird bereitgestellt von NCache.
• Write-Behind-Cache Merkmal von NCache Der Cache wird sofort aktualisiert, Datenbankaktualisierungen werden in eine Warteschlange gestellt und anschließend asynchron im Hintergrund auf die Datenbank angewendet. Dies verbessert die Schreibleistung der Anwendung erheblich, da die Anwendung nicht auf die langsame Datenbankaktualisierung warten muss.
• Im Vergleich zu Cache-Aside: Read-Through/Write-Through-Strategien behandeln den Cache als primären Datenspeicher und abstrahieren die Datenbankinteraktion von der Anwendung. Beim Cache-Aside-Pattern kommuniziert die Anwendung direkt mit der Datenbank und speichert die abgerufenen Daten im Cache.

Unterschied zwischen Cache-Aside und Read-Through/Write-Through

Es gibt zwei Hauptmethoden, wie Benutzer einen verteilten Cache verwenden:

• Cache-beiseite: Hier ist die Anwendung für das Lesen und Schreiben aus der Datenbank verantwortlich, und der Cache interagiert überhaupt nicht mit der Datenbank. Der Cache wird als schnellerer und skalierbarer In-Memory-Datenspeicher „beiseite gelegt“. Die Anwendung überprüft den Cache, bevor sie etwas aus der Datenbank liest, und aktualisiert den Cache nach jeder Aktualisierung der Datenbank. Auf diese Weise stellt die Anwendung sicher, dass die Cache wird mit der Datenbank synchronisiert gehalten.
• Durchlesen / Durchschreiben: Hier behandelt die Anwendung den Cache als Hauptdatenspeicher und liest Daten daraus und schreibt Daten darauf. Der Cache ist für das Lesen und Schreiben dieser Daten in die Datenbank verantwortlich, wodurch die Anwendung von dieser Verantwortung entlastet wird.

Vergleich: Cache-Aside vs. Read-Through vs. Write-Behind

Vorteile von Read-Through-Cache und Write-Through-Cache gegenüber Cache-Aside

Cache-Aside ist eine sehr leistungsfähige Technik und ermöglicht Ihnen, komplexe Datenbankabfragen mit Joins und verschachtelten Abfragen durchzuführen und Daten beliebig zu manipulieren. Trotzdem Durchlesen / Durchschreiben hat verschiedene Vorteile gegenüber Cache-Aside, wie unten erwähnt:

• Anwendungscode vereinfachen: Beim Cache-Aside-Ansatz bleibt Ihr Anwendungscode komplex und direkt von der Datenbank abhängig. Es kommt sogar zu Code-Duplikationen, wenn mehrere Anwendungen mit denselben Daten arbeiten. Read-Through/Write-Through verschiebt einen Teil des Datenzugriffscodes von Ihren Anwendungen in die Caching-Ebene. Dies vereinfacht Ihre Anwendungen erheblich und abstrahiert die Datenbank noch deutlicher.
• Bessere Lese-Skalierbarkeit mit Read-through-Cache: Es gibt viele Situationen, in denen a Cache-Element läuft ab, und mehrere parallele Benutzer-Threads greifen auf die Datenbank zu. Multipliziert man dies mit Millionen zwischengespeicherter Elemente und Tausenden paralleler Benutzeranfragen, steigt die Datenbankbelastung deutlich an. Read-through behält jedoch das Cache-Element im Cache, während die neueste Kopie aus der Datenbank abgerufen wird. Anschließend wird das Cache-Element aktualisiert. Dadurch greift die Anwendung nie auf die Datenbank zu, um diese Cache-Elemente abzurufen, und die Datenbankbelastung wird auf ein Minimum reduziert.
• Bessere Schreibleistung mit Write-behind: Im Cache-Aside-Modus aktualisiert die Anwendung die Datenbank direkt und synchron. Während Hinterschreiben Durch Caching kann Ihre Anwendung den Cache schnell aktualisieren und zurückkehren. Anschließend kann der Cache die Datenbank im Hintergrund aktualisieren.
• Bessere Skalierbarkeit der Datenbank mit Write-Behind: Mit Write-Behind können Sie festlegen Drosselungsgrenzen Daher werden die Datenbankschreibvorgänge nicht so schnell ausgeführt wie die Cache-Aktualisierungen, sodass die Belastung der Datenbank nicht so groß ist. Darüber hinaus können Sie die Datenbankschreibvorgänge so planen, dass sie außerhalb der Spitzenzeiten erfolgen, um die Belastung ebenfalls zu minimieren.
• Cache nach Ablauf automatisch aktualisieren: Durchlesen ermöglicht dem Cache das automatische Neuladen eines Objekts aus der Datenbank, wenn es abläuft. Das bedeutet, dass Ihre Anwendung nicht zu Spitzenzeiten auf die Datenbank zugreifen muss, da sich immer die neuesten Daten im Cache befinden.
• Cache bei Datenbankänderungen automatisch aktualisieren: Der Read-Through-Cache lädt ein Objekt automatisch aus der Datenbank neu, wenn sich die entsprechenden Daten in der Datenbank ändern. Dadurch ist der Cache immer aktuell und Ihre Anwendung muss in Spitzenzeiten nicht auf die Datenbank zugreifen, da sich immer die neuesten Daten im Cache befinden.

Read-Through/Write-Through ist nicht für den gesamten Datenzugriff in Ihrer Anwendung vorgesehen. Es eignet sich am besten für Situationen, in denen Sie entweder einzelne Zeilen aus der Datenbank lesen oder Daten lesen, die direkt einem einzelnen Cache-Element zugeordnet werden können. Es eignet sich auch ideal für Referenzdaten, die für häufige Lesevorgänge im Cache gespeichert werden sollen, auch wenn sich diese Daten regelmäßig ändern.

Implementieren eines Read-Through-Cache

Ein Read-Through-Anbieter in NCache ist eine benutzerdefinierte Klasse IReadThruProvider in .NET, das Daten aus der Quelle (z. B. SQL Server) abruft, wenn sie nicht im Cache gefunden werden. NCache ruft LoadFromSource automatisch auf. Um es zu verwenden, implementieren Sie den Anbieter, stellen Sie ihn mit dem NCache Management Center or Befehlszeilentool und ermöglichen es in den Cache-Einstellungen.

using System.Collections;
using Alachisoft.NCache.Runtime.DatasourceProviders;

public class SampleReadThruProvider : IReadThruProvider
{
    public void Init(IDictionary parameters, string cacheId)
    {
        // Initialize resources if needed
    }

    // Modern "Expression-bodied member" for conciseness
    public ProviderCacheItem LoadFromSource(string key) => 
        new(Database.GetData(key));

    // Using LINQ instead of a foreach loop for cleaner bulk loading
    public IDictionary<string, ProviderCacheItem> LoadFromSource(ICollection<string> keys)
    {
        return keys.ToDictionary(
            key => key, 
            key => new ProviderCacheItem(Database.GetData(key))
        );
    }

    public ProviderDataTypeItem<IEnumerable> LoadDataTypeFromSource(string key, DistributedDataType dataType)
    {
        // "Switch Expression" with "Collection Expressions"
        return dataType switch
        {
            DistributedDataType.List => new([Database.GetData(key)]),
            
            DistributedDataType.Dictionary => new(new Dictionary<string, object>
            { 
                [key] = Database.GetData(key) 
            }),
            
            DistributedDataType.Counter => new(1000),
            
            _ => null! // null-forgiving operator if nullable context is enabled
        };
    }

    public void Dispose()
    {
        // Clean up resources if needed
    }
}

Init() führt bestimmte Ressourcenzuweisungsaufgaben aus, z. B. das Herstellen von Verbindungen zur Hauptdatenquelle, während Dispose() soll alle diese Zuweisungen zurücksetzen.

Implementieren eines Write-Through-Cache

Ein Write-Through-Anbieter in NCache ist eine benutzerdefinierte Klasse, die implementiert IWriteThruProvider um Cache-Updates (Hinzufügen, Aktualisieren, Entfernen) bei jeder Cache-Aktualisierung direkt in der Datenbank zu speichern.

Um es zu verwenden, implementieren Sie die Schnittstelle und stellen Sie sie mithilfe des Anbieters in bereit NCache Management Center und ermöglichen es in der Cache-Konfiguration.

using System.Collections;
using Alachisoft.NCache.Runtime.DatasourceProviders;

public class SampleWriteThruProvider : IWriteThruProvider
{
    public void Init(IDictionary parameters, string cacheId)
    {
        // Initialize resources if needed
    }

    public void Dispose()
    {
        // Clean up resources if needed
    }

    public OperationResult WriteToDataSource(WriteOperation operation)
    {
        var product = operation.ProviderItem.GetValue<Product>();

        // Standard switch is still best for side-effects (void actions)
        switch (operation.OperationType)
        {
            case WriteOperationType.Add:
                // Database.Add(product);
                break;
                
            case WriteOperationType.Update:
                // Database.Update(product);
                break;
                
            case WriteOperationType.Delete:
                // Database.Delete(product);
                break;
        }

        // Target-typed "new" infers the class type automatically
        return new(operation, OperationResult.Status.Success);
    }

    // Modern "Expression-bodied member" using LINQ projection
    public ICollection<OperationResult> WriteToDataSource(ICollection<WriteOperation> operations) =<
        operations.Select(WriteToDataSource).ToList();

    // Handling Data Structures with LINQ
    public ICollection<OperationResult> WriteToDataSource(ICollection<DataTypeWriteOperation> operations) =>
        operations.Select(op =>
            new OperationResult(op, OperationResult.Status.Success)
        ).ToList();
}

Was macht man als nächstes?

• Herunterladen NCache
• Lesen Sie mehr NCache Dokumente zu Caching-Anbietern
• Vergleich: NCache vs Redis