Pastāsti man par kešatmiņas līmeņiem.

Java programmā kešošana var tikt realizēta dažādos līmeņos, katrs ar savām īpatnībām un kompromisiem starp veiktspēju un datu aktualitāti.

Galvenie kešēšanas līmeņi:

1. Procesora kešatmiņa (CPU Cache):

   • L1, L2, L3 kešatmiņas, kas atrodas tieši uz procesora mikroshēmas.
   • Visātrākā, bet mazākā kešatmiņa.
   • Vadīta ar aparatūru, nav tieši pieejama caur standarta Java API.

2. Operētājsistēmas kešatmiņa:

   • Kešē failu, tīkla socketu un citu resursu piekļuvi.
   • Vadīta ar OS. Java lietojumprogramma ar to sadarbojas netieši caur sistēmas izsaukumiem.

3. Java virtuālās mašīnas (JVM) kešatmiņa:

   • JIT kompilators kešē kompilēto kodu.
   • JVM iekšējās optimizācijas (piemēram, String Pool kešošana).
   • Daļēji kontrolēta ar JVM zīmēm, galvenokārt automatizēta.

4. In-Memory Application Cache:

   • Atrodas Java procesa operatīvajā atmiņā.
   • Visbiežāk izmantotais datu kešēšanas līmenis, ko pārvalda izstrādātājs.
   • Izmanto bieži lietojamu objektu vai vaicājumu rezultātu glabāšanai.
   • Piemēri bibliotēkām: Guava Cache, Ehcache, Caffeine.
   • Var būt lokāls (viena JVM ietvaros) vai izplatīts (starp vairākām JVM).

   // Guava izmantošanas piemērs ar In-Memory kešatmiņu
   import com.google.common.cache.CacheBuilder;
   import com.google.common.cache.CacheLoader;
   import com.google.common.cache.LoadingCache;
   
   import java.util.concurrent.TimeUnit;
   
   public class DataCache {
   
       private final LoadingCache<String, String> dataCache;
   
       public DataCache() {
           dataCache = CacheBuilder.newBuilder()
               .maximumSize(100) // Maksimālais elementu skaits
               .expireAfterWrite(10, TimeUnit.MINUTES) // Dzīves ilgums pēc ieraksta
               .build(new CacheLoader<String, String>() {
                   @Override
                   public String load(String key) throws Exception {
                       // Datu ielādes loģika, ja to nav kešā
                       System.out.println("Loading data for key: " + key);
                       return fetchDataFromDatabase(key); // Datu imitācija
                   }
               });
       }
   
       public String getData(String key) {
           try {
               return dataCache.get(key);
           } catch (Exception e) {
               e.printStackTrace();
               return null; // Kļūdu apstrāde
           }
       }
   
       private String fetchDataFromDatabase(String key) {
           // Aizkaves un datu iegūšanas imitācija no ārēja avota
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
           }
           return "Data for " + key;
       }
   
       public static void main(String[] args) {
           DataCache cache = new DataCache();
   
           System.out.println(cache.getData("key1")); // Ielāde no avota, ieraksts kešā
           System.out.println(cache.getData("key1")); // Lasīšana no keša
       }
   }
   

5. Datu bāzes kešatmiņa:

   • Vaicājumu un datu kešošana datu bāzes pusē.
   • Realizējas ar DBMS.

6. Izplatīta kešatmiņa:

   • Kešatmiņa, kas ir izplatīta starp vairākiem serveriem vai mezgliem.
   • Izmanto klastera lietojumprogrammās datu apvienošanai un mērogošanai.
   • Piemēri: Redis, Memcached, Apache Ignite.
   • Prasa risinājumus datu saskaņošanai (konsekvences nodrošināšanai) starp mezgliem.

7. Web servera/API Gateway kešatmiņa:

   • Kešatmiņa tīmekļa servera līmenī (piemēram, Nginx, Apache) vai API Gateway līmenī.
   • HTTP/API pieprasījumu atbilžu kešošana.

8. Pārlūkprogrammas kešatmiņa:

   • Statisko resursu (HTML, CSS, JS, attēli) kešatmiņa lietotāja pārlūkprogrammā.
   • Vadīta ar HTTP galvenes (Cache-Control, Expires).

Kešatmiņas līmeņa izvēle ir atkarīga no datu veida, aktuālitātes prasībām, datu apjoma, mērogojamības un realizācijas sarežģītības.

Bieži tiek izmantota vairāku līmeņu kombinācija.