Single-Flight Caching: ಒಂದು ಹಾಟ್ ಕೀ ಡೇಟಾಬೇಸ್ ಡೌನ್ ಆಗುವುದನ್ನು ಹೇಗೆ ತಡೆಯುತ್ತದೆ

ಒಂದು ವೆಬ್‌ಸೈಟ್‌ಗೆ ಹೆಚ್ಚಿನ ಟ್ರಾಫಿಕ್ ಬಂದಾಗ, ಅದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಡೇಟಾ ಹಿಂಪಡೆಯಲು ಅದು ಡೇಟಾಬೇಸ್ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ. ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಎದುರಿಸುವ ಒಂದು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗೆ ನಾವು ಪರಿಹಾರವನ್ನು ಚರ್ಚಿಸುತ್ತಿದ್ದೇವೆ: ಡೇಟಾಬೇಸ್ ಮೇಲೆ ಅತಿಯಾದ ಹೊರೆ ಹಾಕದೆ ಕ್ಯಾಶ್ ಮುಕ್ತಾಯವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು.

ಸಮಸ್ಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

podbor-minuta.ru ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ, ಕೆಲವು ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಗಳು ಸಾಕಷ್ಟು ಭಾರವಾಗಿರುತ್ತವೆ. ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೇಗಗೊಳಿಸಲು, ಅವರು ಫಲಿತಾಂಶಗಳನ್ನು ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ಅವರು ಲಿಸ್ಟಿಂಗ್ ಪುಟಗಳಿಗಾಗಿ ಅಪಾರ್ಟ್‌ಮೆಂಟ್ ಪಟ್ಟಿಗಳು ಮತ್ತು ಒಟ್ಟು ಸಂಖ್ಯೆಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡುತ್ತಾರೆ. ಕ್ಯಾಶ್ ಮಾನ್ಯವಾಗಿದ್ದಾಗ, ಎಲ್ಲವೂ ಸುಗಮವಾಗಿ ನಡೆಯುತ್ತದೆ. ಆದರೆ, ಕ್ಯಾಶ್ ಮುಕ್ತಾಯಗೊಂಡಾಗ ಸಮಸ್ಯೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಒಂದು ದಿನ, ಹೆಚ್ಚಿನ ಲೋಡ್ ಸಮಯದಲ್ಲಿ, ಸೈಟ್ ಗಂಭೀರ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿತು. 500 ಪ್ರತಿಕ್ರಿಯೆಗಳ ಬ್ಯಾಚ್ ಟೈಮ್‌ಔಟ್ ಆಯಿತು. ಡೇಟಾಬೇಸ್ ಇನ್ನೂ ಚಾಲನೆಯಲ್ಲಿದ್ದರೂ, ಕ್ವೆರಿಗಳು ಕ್ಯೂನಲ್ಲಿ ಸಾಲುಗಟ್ಟಲು ಪ್ರಾರಂಭಿಸಿದವು. ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ವಿನಂತಿಗಳು ಒಂದೇ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರಿಂದ ಈ ಪರಿಸ್ಥಿತಿ ಉಂಟಾಯಿತು, ಇದು ಅಡಚಣೆಗೆ (bottleneck) ಕಾರಣವಾಯಿತು.

Cache Stampede ಎಂದರೇನು?

ಆರಂಭಿಕ ಕ್ಯಾಶಿಂಗ್ ಲಾಜಿಕ್ ಸರಳವಾಗಿತ್ತು: ಮೌಲ್ಯವು ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಅದನ್ನು ಲೆಕ್ಕಹಾಕಲು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಕ್ವೆರಿ ಮಾಡುತ್ತದೆ, ನಂತರ ಆ ಮೌಲ್ಯವನ್ನು ಮತ್ತೆ ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದು ಒಂದೇ ವಿನಂತಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಆದರೆ ಕ್ಯಾಶ್ ಮುಕ್ತಾಯಗೊಂಡು, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಒಂದೇ ಡೇಟಾಕ್ಕಾಗಿ ಇನ್ನೂರು ವಿನಂತಿಗಳು ಬಂದರೆ ಊಹಿಸಿಕೊಳ್ಳಿ. ಪ್ರತಿಯೊಂದು ವಿನಂತಿಯೂ ಕ್ಯಾಶ್ ಖಾಲಿಯಾಗಿದೆ ಎಂದು ನೋಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ಏಕಕಾಲದಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಕ್ವೆರಿ ಮಾಡುತ್ತದೆ. ಈ ಸನ್ನಿವೇಶವನ್ನು ಹೀಗೆ ಕರೆಯಲಾಗುತ್ತದೆ: cache stampede.

cache stampede ಸಮಯದಲ್ಲಿ, ಡೇಟಾಬೇಸ್ ಒಂದೇ ರೀತಿಯ ಭಾರವಾದ ಕ್ವೆರಿಗಳಿಂದ ಅತಿಯಾದ ಹೊರೆಗೆ ಒಳಗಾಗುತ್ತದೆ, ಇದರಿಂದ ಕನೆಕ್ಷನ್ ಮಿತಿಗಳು ತಲುಪುತ್ತವೆ. ಪರಿಣಾಮವಾಗಿ, ಟೈಮ್‌ಔಟ್‌ಗಳ ಕಾರಣದಿಂದಾಗಿ ಕೆಲವು ವಿನಂತಿಗಳು ಕೈಬಿಡಲ್ಪಡುತ್ತವೆ.

Single-Flight Caching ಅನ್ನು ಅಳವಡಿಸುವುದು

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ತಂಡವು ಈ ಹೆಸರಿನ ತಂತ್ರವನ್ನು ಅಳವಡಿಸಿಕೊಂಡಿತು: single-flight caching. ನಿರ್ದಿಷ್ಟ ಕೀಗಾಗಿ ಲೆಕ್ಕಾಚಾರವು ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ, ಅದೇ ಕೀಗಾಗಿ ಬರುವ ಯಾವುದೇ ಇತರ ವಿನಂತಿಗಳು ತಮ್ಮದೇ ಆದ ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಬದಲು ಫಲಿತಾಂಶಕ್ಕಾಗಿ ಕಾಯುತ್ತವೆ ಎಂಬುದನ್ನು ಈ ವಿಧಾನವು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಹಂತ 1: ಕ್ಯಾಶ್ ಪರಿಶೀಲಿಸಿ

ಮೊದಲು, ಮೌಲ್ಯವು ಈಗಾಗಲೇ ಕ್ಯಾಶ್‌ನಲ್ಲಿದೆಯೇ ಎಂದು ಅಪ್ಲಿಕೇಶನ್ ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದ್ದರೆ, ಅದು ಆ ಮೌಲ್ಯವನ್ನು ತಕ್ಷಣವೇ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಹಂತ 2: Cache Miss ಗಳನ್ನು ನಿರ್ವಹಿಸಿ

ಮೌಲ್ಯವು ಕ್ಯಾಶ್‌ನಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ಆ ಕೀಗಾಗಿ ಲೆಕ್ಕಾಚಾರವು ಈಗಾಗಲೇ ಪ್ರಗತಿಯಲ್ಲಿದೆಯೇ ಎಂದು ಅದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಆ ಲೆಕ್ಕಾಚಾರ ಮುಗಿಯುವವರೆಗೆ ಕಾಯುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಹಂತ 3: Promise ಒಂದನ್ನು ರಚಿಸಿ

ಯಾವುದೇ ಲೆಕ್ಕಾಚಾರವು ಪ್ರಗತಿಯಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಒಂದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು ಲೆಕ್ಕಾಚಾರಕ್ಕಾಗಿ promise ಒಂದನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಕೀಯನ್ನು ಬಳಸಿ ಅದನ್ನು map ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಈ ರೀತಿಯಾಗಿ, ಇತರ ವಿನಂತಿಗಳು ಹೊಸ ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಬದಲು ಅದೇ promise ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸರಳೀಕೃತ ಕೋಡ್ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

const inFlight = new Map<string, Promise<unknown>>();

async function getOrSet<T>(key: string, compute: () => Promise<T>): Promise<T> {
    const cached = cache.get(key);
    if (cached !== undefined) return cached as T;

    const running = inFlight.get(key);
    if (running) return running as Promise<T>;

    const promise = compute().then((value) => {
        cache.set(key, value);
        return value;
    }).finally(() => {
        inFlight.delete(key);
    });

    inFlight.set(key, promise);
    return promise;
}

Single-Flight Caching ನ ಪ್ರಯೋಜನಗಳು

single-flight caching ನ ಅನುಷ್ಠಾನವು ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ತಂದಿತು:

• ಡೇಟಾಬೇಸ್ ಮೇಲಿನ ಹೊರೆ ಕಡಿಮೆಯಾಗಿದೆ: ಇನ್ನೂರು ಒಂದೇ ರೀತಿಯ ಕ್ವೆರಿಗಳ ಬದಲಿಗೆ, ಕೇವಲ ಒಂದು ಕ್ವೆರಿ ಮಾತ್ರ ಡೇಟಾಬೇಸ್‌ಗೆ ಹೋಗುತ್ತದೆ, ಇದು ಹೊರೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ: connection pool ಇನ್ನು ಮುಂದೆ ಅನಗತ್ಯವಾಗಿ ಖಾಲಿಯಾಗುವುದಿಲ್ಲ, ಇದು ಹೆಚ್ಚಿನ ಟ್ರಾಫಿಕ್ ಸಮಯದಲ್ಲಿ ಸುಗಮ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ದಕ್ಷತೆ: cache-hit ಪಾತ್ ವೇಗವಾಗಿ ಉಳಿಯುತ್ತದೆ, ಕ್ಯಾಶ್‌ನಲ್ಲಿ ತಮ್ಮ ಡೇಟಾವನ್ನು ಕಂಡುಕೊಳ್ಳುವ ವಿನಂತಿಗಳಿಗೆ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಓವರ್‌ಹೆಡ್ ಇರುವುದಿಲ್ಲ.

ತೀರ್ಮಾನ

Single-flight caching ಎಂಬುದು ಗರಿಷ್ಠ ಬಳಕೆಯ ಸಮಯದಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಕ್ಯಾಶ್ ಮುಕ್ತಾಯಗೊಂಡಾಗ ಡೇಟಾಬೇಸ್ ಲೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಪರಿಣಾಮಕಾರಿ ತಂತ್ರವಾಗಿದೆ. ಒಂದು ಸಮಯದಲ್ಲಿ ಕೇವಲ ಒಂದು ವಿನಂತಿ ಮಾತ್ರ ಭಾರವಾದ ಕ್ವೆರಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಸರ್ವರ್ ಕ್ರ್ಯಾಶ್‌ಗಳನ್ನು ತಡೆಯಬಹುದು.

ಅನುಕೂಲಗಳು

• ಕ್ಯಾಶ್ ಮುಕ್ತಾಯದ ಸಮಯದಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಓವರ್‌ಲೋಡ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ.
• ಕ್ಯಾಶ್ ಮಾಡಿದ ಡೇಟಾಗಾಗಿ ವೇಗದ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುತ್ತದೆ.
• ನಕಲಿ ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಅನನುಕೂಲಗಳು

• in-flight ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚುವರಿ ಲಾಜಿಕ್ ಅಗತ್ಯವಿದೆ.
• ಕಟ್ಟುನಿಟ್ಟಾದ ಪರಿಸರಗಳಿಗೆ shared lock ಅಗತ್ಯವಿರಬಹುದು, ಇದು ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.

ಎಚ್ಚರಿಕೆ

ಈ ಲೇಖನವು ಶೈಕ್ಷಣಿಕ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾತ್ರ. ನೀವು ಯಾವುದೇ ಕ್ಯಾಶಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿದರೆ, ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಮೌಲ್ಯಗಳನ್ನು ನಿಮ್ಮ ನೈಜ ಡೇಟಾದೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ಮರೆಯದಿರಿ ಮತ್ತು ಅವುಗಳನ್ನು ಅವಲಂಬಿಸುವ ಮೊದಲು ಮೂಲ ಆಕರಗಳೊಂದಿಗೆ ಪರಿಶೀಲಿಸಿ.

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

• single-flight caching ಎಂದರೇನು? — ಇದು ಒಂದು ಕ್ಯಾಶಿಂಗ್ ತಂತ್ರವಾಗಿದ್ದು, ಒಂದು ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕೀಗಾಗಿ ಡೇಟಾವನ್ನು ತರಲು ಕೇವಲ ಒಂದು ವಿನಂತಿಯನ್ನು ಮಾತ್ರ ಅನುಮತಿಸುತ್ತದೆ, ಇದರಿಂದ ಅನೇಕ ಡೇಟಾಬೇಸ್ ಕ್ವೆರಿಗಳನ್ನು ತಡೆಯಲಾಗುತ್ತದೆ.
• cache stampede ಎಂದರೇನು? — cache miss ಆದ ನಂತರ ಒಂದೇ ಡೇಟಾಕ್ಕಾಗಿ ಅನೇಕ ವಿನಂತಿಗಳು ಏಕಕಾಲದಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ಗೆ ತಲುಪಿ, ಡೇಟಾಬೇಸ್ ಮೇಲೆ ಅತಿಯಾದ ಹೊರೆ ಉಂಟುಮಾಡುವ ಪರಿಸ್ಥಿತಿ.
• ಕ್ಯಾಶಿಂಗ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸುತ್ತದೆ? — ಕ್ಯಾಶಿಂಗ್ ಪದೇ ಪದೇ ಪ್ರವೇಶಿಸುವ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಇದು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಕ್ವೆರಿ ಮಾಡುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿ ಡೇಟಾ ಹಿಂಪಡೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
• ಕ್ಯಾಶ್ ಮುಕ್ತಾಯಗೊಂಡಾಗ ಏನಾಗುತ್ತದೆ? — ಕ್ಯಾಶ್ ಮುಕ್ತಾಯಗೊಂಡಾಗ, ಒಂದೇ ಡೇಟಾಕ್ಕಾಗಿ ವಿನಂತಿಗಳು ಡೇಟಾಬೇಸ್‌ಗೆ ಮುಗಿಬೀಳಬಹುದು, ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸದಿದ್ದರೆ ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• single-flight caching ಅನ್ನು ಅನೇಕ ಸರ್ವರ್‌ಗಳೊಂದಿಗೆ ಬಳಸಬಹುದೇ? — ಹೌದು, ಆದರೆ ವಿಭಿನ್ನ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ವಿನಂತಿಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು shared locks ನಂತಹ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವಿಧಾನಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ.
• ಕ್ಯಾಶಿಂಗ್‌ನ ಪ್ರಯೋಜನಗಳೇನು? — ಕ್ಯಾಶಿಂಗ್ ಡೇಟಾಬೇಸ್ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಡೇಟಾ ಹಿಂಪಡೆಯುವಿಕೆಯನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಒಟ್ಟಾರೆ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಟ್ಯಾಗ್‌ಗಳು

#caching #database #performance #webdev #architecture #softwaredevelopment #programming #tech