Programmiertechnologie-Cache-Schreibmethode (1)

Einführung

In diesem Artikel geht es hauptsächlich um die Erfahrungen mit der Verwendung des Caches und die Probleme, die bei täglichen Projekten auftreten.

Verzeichnis

1: Grundlegende Schreibmethode

2: Cache-Lawine

1: Globale Sperre, Instanzsperre

2: Zeichenfolge Sperren

Drei: Cache-Penetration

Viertens: Reden wir über Cache-Lawine

Fünftens: Zusammenfassung

Eins: Grundlegendes Schreiben

Für Zur Vereinfachung der Demonstration verwenden wir Runtime.Cache als Cache-Container und definieren eine einfache Operationsklasse. Wie folgt:

public class CacheHelper
   {
       public static object Get(string cacheKey)
       {
           return HttpRuntime.Cache[cacheKey];
       }
       public static void Add(string cacheKey, object obj, int cacheMinute)
       {
           HttpRuntime.Cache.Insert(cacheKey, obj, null, DateTime.Now.AddMinutes(cacheMinute),
               Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
       }
   }

Einfaches Lesen:

public object GetMemberSigninDays1()
    {
        const int cacheTime = 5;
        const string cacheKey = "mushroomsir";
 
        var cacheValue = CacheHelper.Get(cacheKey);
        if (cacheValue != null)
            return cacheValue;
 
        cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
        CacheHelper.Add(cacheKey, cacheValue, cacheTime);
        return cacheValue;
    }

Im Projekt gibt es viele Arten, wie diese zu schreiben. Es ist nichts Falsches daran, auf diese Weise zu schreiben, aber es wird Probleme geben, wenn die Parallelität zunimmt. Weiterlesen

Zweitens: Cache-Lawine

Die Cache-Lawine ist auf eine Cache-Ungültigmachung (Ablauf) zurückzuführen und der neue Cache ist noch nicht abgelaufen.

Während dieser Zwischenzeit werden alle Anfragen an die Datenbank gesendet, was eine enorme Belastung für die Datenbank-CPU und den Speicher darstellt. Es sind nicht genügend Front-End-Verbindungen vorhanden und die Abfrage wird blockiert.

Diese Zwischenzeit ist nicht so kurz, z. B. 1 Sekunde für die SQL-Abfrage plus 0,5 Sekunden für die Übertragung und Analyse. Das heißt, alle Benutzerabfragen innerhalb von 1,5 Sekunden fragen direkt die Datenbank ab.

In diesem Fall denken wir am meisten an Absperren und Anstehen.

1: Globale Sperre, Instanzsperre

public static object obj1 = new object();
       public object GetMemberSigninDays2()
       {
           const int cacheTime = 5;
           const string cacheKey = "mushroomsir";
 
           var cacheValue = CacheHelper.Get(cacheKey);
 
           if (cacheValue != null)
               return cacheValue;
 
           //lock (obj1)         //全局锁
           //{
           //    cacheValue = CacheHelper.Get(cacheKey);
           //    if (cacheValue != null)
           //        return cacheValue;
           //    cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
           //    CacheHelper.Add(cacheKey, cacheValue, cacheTime);
           //}
           lock (this)
           {
               cacheValue = CacheHelper.Get(cacheKey);
               if (cacheValue != null)
                   return cacheValue;
 
               cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
               CacheHelper.Add(cacheKey, cacheValue, cacheTime);
           }
           return cacheValue;
       }

Der erste Typ: Sperre (obj1) ist eine globale Sperre, die erfüllt werden kann, aber wir müssen für jede Funktion ein obj deklarieren. andernfalls Wenn die Funktionen A und B beide obj1 sperren, wird zwangsläufig eine von ihnen blockiert.

Der zweite Typ: lock (this) sperrt die aktuelle Instanz und ist für andere Instanzen ungültig. Diese Sperre hat keine Wirkung. Sie können den Singleton-Modus verwenden, um zu sperren.

Aber in der aktuellen Instanz: Funktion A sperrt die aktuelle Instanz, und andere Funktionen, die die aktuelle Instanz sperren, werden auch beim Lesen und Schreiben blockiert. Unerwünscht

2: String-Sperre

Da das Sperren von Objekten nicht möglich ist, können wir den Cache-Schlüssel direkt sperren, indem wir die Eigenschaften von Strings verwenden. Werfen wir einen Blick auf

public object GetMemberSigninDays3()
       {
           const int cacheTime = 5;
           const string cacheKey = "mushroomsir";
 
           var cacheValue = CacheHelper.Get(cacheKey);
           if (cacheValue != null)
               return cacheValue;
           const string lockKey = cacheKey + "n(*≧▽≦*)n";
 
           //lock (cacheKey)
           //{
           //    cacheValue = CacheHelper.Get(cacheKey);
           //    if (cacheValue != null)
           //        return cacheValue;
           //    cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
           //    CacheHelper.Add(cacheKey, cacheValue, cacheTime);
           //}
           lock (lockKey)
           {
               cacheValue = CacheHelper.Get(cacheKey);
               if (cacheValue != null)
                   return cacheValue;
               cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
               CacheHelper.Add(cacheKey, cacheValue, cacheTime);
           }
           return cacheValue;
       }

Das erste: lock (cacheName) ist problematisch, da die Zeichenfolge ebenfalls gemeinsam genutzt wird und andere Vorgänge, die diese Zeichenfolge verwenden, blockiert. Einzelheiten finden Sie im vorherigen Blog-Beitrag „C# Language-Lock System in Multi-Threading“ (1).

2015-01-04 13:36 Update: Da Zeichenfolgen von der Common Language Runtime (CLR) beibehalten werden, bedeutet dies, dass es im gesamten Programm nur eine Instanz einer bestimmten Zeichenfolge gibt. Deshalb verwenden wir den zweiten Typ

Der zweite Typ: lock (lockKey) ist ausreichend. Tatsächlich besteht der Zweck darin, die minimale Granularität der Sperre und die globale Eindeutigkeit sicherzustellen und nur das aktuell zwischengespeicherte Abfrageverhalten zu sperren.

3: Cache-Penetration

Ein einfaches Beispiel: Im Allgemeinen speichern wir Benutzersuchergebnisse im Cache. Wenn die Datenbank sie nicht abfragen kann, wird sie nicht zwischengespeichert. Wenn Sie dieses Schlüsselwort jedoch häufig überprüfen, wird die Datenbank jedes Mal direkt überprüft.

Caching ist auf diese Weise bedeutungslos, was auch ein häufig angesprochenes Problem der Cache-Trefferquote ist.

public object GetMemberSigninDays4()
      {
          const int cacheTime = 5;
          const string cacheKey = "mushroomsir";
 
          var cacheValue = CacheHelper.Get(cacheKey);
          if (cacheValue != null)
              return cacheValue;
          const string lockKey = cacheKey + "n(*≧▽≦*)n";
 
          lock (lockKey)
          {
              cacheValue = CacheHelper.Get(cacheKey);
              if (cacheValue != null)
                  return cacheValue;
 
              cacheValue = null; //数据库查询不到，为空。
              //if (cacheValue2 == null)
              //{
              //    return null;  //一般为空，不做缓存
              //}
              if (cacheValue == null)
              {
                  cacheValue = string.Empty; //如果发现为空，我设置个默认值，也缓存起来。
              }
              CacheHelper.Add(cacheKey, cacheValue, cacheTime);
          }
          return cacheValue;
      }

Im Beispiel speichern wir auch die Ergebnisse zwischen, die nicht abgefragt werden können. Dadurch kann eine Cache-Penetration vermieden werden, wenn die Abfrage leer ist.

Natürlich können wir auch einen separaten Cache-Bereich einrichten, um eine Kontrollüberprüfung der ersten Ebene durchzuführen. Zur Unterscheidung vom normalen Cache.

四：再谈缓存雪崩

额 不是用加锁排队方式就解决了吗？其实加锁排队只是为了减轻DB压力，并没有提高系统吞吐量。

在高并发下： 缓存重建期间，你是锁着的，1000个请求999个都在阻塞的。 用户体验不好，还浪费资源：阻塞的线程本可以处理后续请求的。

public object GetMemberSigninDays5()
        {
            const int cacheTime = 5;
            const string cacheKey = "mushroomsir";
 
            //缓存标记。
            const string cacheSign = cacheKey + "_Sign";
            var sign = CacheHelper.Get(cacheSign);
 
            //获取缓存值
            var cacheValue = CacheHelper.Get(cacheKey);
            if (sign != null)
                return cacheValue; //未过期，直接返回。
 
            lock (cacheSign)
            {
                sign = CacheHelper.Get(cacheSign);
                if (sign != null)
                    return cacheValue;
 
                CacheHelper.Add(cacheSign, "1", cacheTime);
                ThreadPool.QueueUserWorkItem((arg) =>
                {
                    cacheValue = "395"; //这里一般是 sql查询数据。 例：395 签到天数
                    CacheHelper.Add(cacheKey, cacheValue, cacheTime*2); //日期设缓存时间的2倍，用于脏读。
                });
            }
            return cacheValue;
        }

代码中，我们多用个缓存标记key，双检锁校验。它设置为正常时间，过期后通知另外的线程去更新缓存数据。

而实际的缓存由于设置了2倍的时间，仍然可以能用脏数据给前端展现。

这样就能提高不少系统吞吐量了。

五：总结

补充下： 这里说的阻塞其他函数指的是，高并发下锁同一对象。

实际使用中，缓存层封装往往要复杂的多。 关于更新缓存，可以单开一个线程去专门跑这些，图方便就扔线程池吧。

具体使用场景，可根据实际用户量来平衡。