ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್: ವರ್ಧಿತ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಪ್ಯಾರಲಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಕಾರ್ಯಾಚರಣೆಗಳು

ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ನೋಡ್.ಜೆಎಸ್ (Node.js) ಪರಿಸರದಲ್ಲಿ ಮತ್ತು ವೆಬ್ ವರ್ಕರ್ಸ್ ಬಳಸುವ ವೆಬ್ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ, ಸಮಕಾಲೀನ (concurrent) ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯವು ಹೆಚ್ಚು ನಿರ್ಣಾಯಕವಾಗುತ್ತಿದೆ. ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ಸಮಕಾಲೀನತೆಯು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಗಮನಾರ್ಹವಾಗಿ ಪರಿಣಾಮ ಬೀರುವ ಒಂದು ಕ್ಷೇತ್ರವಾಗಿದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಾಟಕೀಯವಾಗಿ ಸುಧಾರಿಸಬಲ್ಲ ಪ್ಯಾರಲಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಒಂದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ.

ಕನ್ಕರೆಂಟ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳ ಅಗತ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಾಂಪ್ರದಾಯಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳಾದ ಅಂತರ್ನಿರ್ಮಿತ Map ಮತ್ತು Object, ಮೂಲಭೂತವಾಗಿ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಆಗಿರುತ್ತವೆ. ಇದರರ್ಥ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಕೇವಲ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯು ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಅಥವಾ ಮಾರ್ಪಡಿಸಬಹುದು. ಇದು ಪ್ರೋಗ್ರಾಂ ನಡವಳಿಕೆಯ ಬಗ್ಗೆ ತಾರ್ಕಿಕತೆಯನ್ನು ಸರಳಗೊಳಿಸಿದರೂ, ಈ ಕೆಳಗಿನ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಇದು ಅಡಚಣೆಯಾಗಬಹುದು:

• ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಪರಿಸರಗಳು: ವೆಬ್ ವರ್ಕರ್ಸ್ ಬಳಸಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಪ್ಯಾರಲಲ್ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ಚಲಾಯಿಸುವಾಗ, ಅನೇಕ ವರ್ಕರ್‌ಗಳಿಂದ ಏಕಕಾಲದಲ್ಲಿ ಹಂಚಿಕೆಯಾದ Map ಅನ್ನು ಪ್ರವೇಶಿಸುವುದರಿಂದ ರೇಸ್ ಕಂಡೀಶನ್ಸ್ (race conditions) ಮತ್ತು ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
• ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು: ನೋಡ್.ಜೆಎಸ್ ಅಥವಾ ಬ್ರೌಸರ್-ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಹಲವಾರು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಗಳೊಂದಿಗೆ (ಉದಾಹರಣೆಗೆ, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು, ಫೈಲ್ I/O) ವ್ಯವಹರಿಸುವಾಗ, ಅನೇಕ ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಏಕಕಾಲದಲ್ಲಿ Map ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು, ಇದು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ಹೆಚ್ಚಿನ-ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು: ನೈಜ-ಸಮಯದ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ, ಗೇಮ್ ಅಭಿವೃದ್ಧಿ, ಅಥವಾ ವೈಜ್ಞಾನಿಕ ಸಿಮ್ಯುಲೇಶನ್‌ಗಳಂತಹ ತೀವ್ರವಾದ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಅವಶ್ಯಕತೆಗಳಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಕನ್ಕರೆಂಟ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು ನೀಡುವ ಪ್ಯಾರಲಲಿಸಂನಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದು.

ಒಂದು ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಏಕಕಾಲದಲ್ಲಿ ಅನೇಕ ಥ್ರೆಡ್‌ಗಳು ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭಗಳಿಂದ ಮ್ಯಾಪ್‌ನ ವಿಷಯಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಈ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದು ಕಾರ್ಯಾಚರಣೆಗಳ ಪ್ಯಾರಲಲ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಕೆಲವು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಎಂದರೇನು?

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಎನ್ನುವುದು ಒಂದು ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಆಗಿದ್ದು, ಇದು ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ ಅಥವಾ ರೇಸ್ ಕಂಡೀಶನ್‌ಗಳನ್ನು ಉಂಟುಮಾಡದೆ ಅನೇಕ ಥ್ರೆಡ್‌ಗಳು ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಅದರ ವಿಷಯಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕೆಳಗಿನವುಗಳ ಬಳಕೆಯಿಂದ ಸಾಧಿಸಲಾಗುತ್ತದೆ:

• ಅಟಾಮಿಕ್ ಕಾರ್ಯಾಚರಣೆಗಳು: ಒಂದೇ, ಅವಿಭಾಜ್ಯ ಘಟಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕಾರ್ಯಾಚರಣೆಗಳು, ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯದಲ್ಲಿ ಬೇರೆ ಯಾವುದೇ ಥ್ರೆಡ್ ಹಸ್ತಕ್ಷೇಪ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಲಾಕಿಂಗ್ ಯಾಂತ್ರಿಕತೆಗಳು: ಮ್ಯೂಟೆಕ್ಸ್‌ಗಳು (mutexes) ಅಥವಾ ಸೆಮಾಫೋರ್‌ಗಳಂತಹ (semaphores) ತಂತ್ರಗಳು, ಇದು ಒಂದೇ ಬಾರಿಗೆ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ನ ನಿರ್ದಿಷ್ಟ ಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಕೇವಲ ಒಂದು ಥ್ರೆಡ್‌ಗೆ ಮಾತ್ರ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಏಕಕಾಲೀನ ಮಾರ್ಪಾಡುಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
• ಲಾಕ್-ಫ್ರೀ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು: ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಟಾಮಿಕ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಚತುರ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಪಷ್ಟವಾದ ಲಾಕಿಂಗ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪಿಸುವ ಸುಧಾರಿತ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು.

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ನ ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನದ ವಿವರಗಳು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಮತ್ತು ಆಧಾರವಾಗಿರುವ ಹಾರ್ಡ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಬದಲಾಗುತ್ತವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಭಾಷೆಯ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಸ್ವಭಾವದಿಂದಾಗಿ ನಿಜವಾದ ಕನ್ಕರೆಂಟ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸವಾಲಿನ ಸಂಗತಿಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ವೆಬ್ ವರ್ಕರ್ಸ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಂತಹ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಸೂಕ್ತವಾದ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಯಾಂತ್ರಿಕತೆಗಳೊಂದಿಗೆ ನಾವು ಕನ್ಕರೆನ್ಸಿಯನ್ನು ಅನುಕರಿಸಬಹುದು.

ವೆಬ್ ವರ್ಕರ್ಸ್‌ನೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕನ್ಕರೆನ್ಸಿಯನ್ನು ಅನುಕರಿಸುವುದು

ವೆಬ್ ವರ್ಕರ್ಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ನಮಗೆ ಬ್ರೌಸರ್ ಪರಿಸರದಲ್ಲಿ ಕನ್ಕರೆನ್ಸಿಯನ್ನು ಅನುಕರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. Map ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ನಾವು ಕೆಲವು ಗಣನಾತ್ಮಕವಾಗಿ ತೀವ್ರವಾದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಯಸುವ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ.

ಉದಾಹರಣೆ: ವೆಬ್ ವರ್ಕರ್ಸ್ ಮತ್ತು ಹಂಚಿಕೆಯಾದ ಮ್ಯಾಪ್‌ನೊಂದಿಗೆ ಪ್ಯಾರಲಲ್ ಡೇಟಾ ಸಂಸ್ಕರಣೆ

ನಮ್ಮ ಬಳಿ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುವ Map ಇದೆ ಎಂದು ಭಾವಿಸೋಣ, ಮತ್ತು ನಾವು ಪ್ರತಿ ದೇಶದಲ್ಲಿನ ಬಳಕೆದಾರರ ಸರಾಸರಿ ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. ನಾವು ಡೇಟಾವನ್ನು ಅನೇಕ ವೆಬ್ ವರ್ಕರ್ಸ್‌ಗಳ ನಡುವೆ ವಿಂಗಡಿಸಬಹುದು ಮತ್ತು ಪ್ರತಿಯೊಬ್ಬ ವರ್ಕರ್ ಏಕಕಾಲದಲ್ಲಿ ಡೇಟಾದ ಉಪವಿಭಾಗವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಂತೆ ಮಾಡಬಹುದು.

ಮುಖ್ಯ ಥ್ರೆಡ್ (index.html ಅಥವಾ main.js):

// Create a large Map of user data
const userData = new Map();
for (let i = 0; i < 10000; i++) {
  const country = ['USA', 'Canada', 'UK', 'Germany', 'France'][i % 5];
  userData.set(i, { age: Math.floor(Math.random() * 60) + 18, country });
}

// Divide the data into chunks for each worker
const numWorkers = 4;
const chunkSize = Math.ceil(userData.size / numWorkers);
const dataChunks = [];
let i = 0;
for (let j = 0; j < numWorkers; j++) {
  const chunk = new Map();
  let count = 0;
  for (; i < userData.size && count < chunkSize; i++) {
    chunk.set(i, userData.get(i));
    count++;
  }
  dataChunks.push(chunk);
}

// Create Web Workers
const workers = [];
const results = new Map();
let completedWorkers = 0;

for (let i = 0; i < numWorkers; i++) {
  const worker = new Worker('worker.js');
  workers.push(worker);

  worker.onmessage = (event) => {
    const { countryAverages } = event.data;
    // Merge results from the worker
    for (const [country, average] of countryAverages) {
      if (results.has(country)) {
        const existing = results.get(country);
        results.set(country, { sum: existing.sum + average.sum, count: existing.count + average.count });
      } else {
        results.set(country, average);
      }
    }

    completedWorkers++;
    if (completedWorkers === numWorkers) {
      // All workers have finished
      const finalAverages = new Map();
      for (const [country, data] of results) {
        finalAverages.set(country, data.sum / data.count);
      }
      console.log('Final Averages:', finalAverages);
    }

    worker.terminate(); // Terminate the worker after use
  };

  worker.onerror = (error) => {
    console.error('Worker error:', error);
  };

  // Send data chunk to the worker
  worker.postMessage({ data: Array.from(dataChunks[i]) });
}

ವೆಬ್ ವರ್ಕರ್ (worker.js):

self.onmessage = (event) => {
  const { data } = event.data;
  const userData = new Map(data);
  const countryAverages = new Map();

  for (const [id, user] of userData) {
    const { country, age } = user;
    if (countryAverages.has(country)) {
      const existing = countryAverages.get(country);
      countryAverages.set(country, { sum: existing.sum + age, count: existing.count + 1 });
    } else {
      countryAverages.set(country, { sum: age, count: 1 });
    }
  }

  self.postMessage({ countryAverages: countryAverages });
};

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

• ಅಟಾಮಿಕ್ ಅಪ್‌ಡೇಟ್‌ಗಳು: ಒಂದು ವೇಳೆ ಒಟ್ಟುಗೂಡಿಸುವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ನಿರ್ವಹಿಸಬಹುದಾದರೆ, ವರ್ಕರ್‌ಗಳಿಂದ ನೇರವಾಗಿ ಹಂಚಿಕೆಯಾದ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಲು ನೀವು SharedArrayBuffer ಮತ್ತು Atomics ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸಬಹುದು. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನಕ್ಕೆ ಎಚ್ಚರಿಕೆಯ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅಗತ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಸರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಂಕೀರ್ಣವಾಗಬಹುದು.
• ಸಂದೇಶ ರವಾನೆ: ಮುಖ್ಯ ಥ್ರೆಡ್‌ನಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವ ಬದಲು, ವರ್ಕರ್‌ಗಳು ಭಾಗಶಃ ಫಲಿತಾಂಶಗಳನ್ನು ಪರಸ್ಪರ ಕಳುಹಿಸುವಂತೆ ಮಾಡಬಹುದು, ವಿಲೀನಗೊಳಿಸುವ ಕೆಲಸದ ಹೊರೆಯನ್ನು ಅನೇಕ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ವಿತರಿಸಬಹುದು.

ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಲಾಕ್‌ಗಳೊಂದಿಗೆ ಮೂಲಭೂತ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

ವೆಬ್ ವರ್ಕರ್ಸ್ ನಿಜವಾದ ಪ್ಯಾರಲಲಿಸಂ ಅನ್ನು ಒದಗಿಸಿದರೂ, ನಾವು ಒಂದೇ ಥ್ರೆಡ್‌ನೊಳಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಲಾಕಿಂಗ್ ಯಾಂತ್ರಿಕತೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕನ್ಕರೆನ್ಸಿಯನ್ನು ಅನುಕರಿಸಬಹುದು. I/O-ಬೌಂಡ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಸಾಮಾನ್ಯವಾದ ನೋಡ್.ಜೆಎಸ್ ಪರಿಸರದಲ್ಲಿ ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸರಳ ಲಾಕಿಂಗ್ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಬಳಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ನ ಮೂಲಭೂತ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

class ConcurrentMap {
  constructor() {
    this.map = new Map();
    this.lock = false; // Simple lock using a boolean flag
  }

  async get(key) {
    while (this.lock) {
      // Wait for the lock to be released
      await new Promise((resolve) => setTimeout(resolve, 0));
    }
    return this.map.get(key);
  }

  async set(key, value) {
    while (this.lock) {
      // Wait for the lock to be released
      await new Promise((resolve) => setTimeout(resolve, 0));
    }
    this.lock = true; // Acquire the lock
    try {
      this.map.set(key, value);
    } finally {
      this.lock = false; // Release the lock
    }
  }

  async delete(key) {
    while (this.lock) {
      // Wait for the lock to be released
      await new Promise((resolve) => setTimeout(resolve, 0));
    }
    this.lock = true; // Acquire the lock
    try {
      this.map.delete(key);
    } finally {
      this.lock = false; // Release the lock
    }
  }
}

// Example Usage
async function example() {
  const concurrentMap = new ConcurrentMap();

  // Simulate concurrent access
  const promises = [];
  for (let i = 0; i < 10; i++) {
    promises.push(
      (async () => {
        await concurrentMap.set(i, `Value ${i}`);
        console.log(`Set ${i}:`, await concurrentMap.get(i));
        await concurrentMap.delete(i);
        console.log(`Deleted ${i}:`, await concurrentMap.get(i));
      })()
    );
  }

  await Promise.all(promises);
  console.log('Finished!');
}

example();

ಈ ಉದಾಹರಣೆಯು ಲಾಕ್ ಆಗಿ ಸರಳವಾದ ಬೂಲಿಯನ್ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. Map ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಅಥವಾ ಮಾರ್ಪಡಿಸುವ ಮೊದಲು, ಪ್ರತಿಯೊಂದು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯು ಲಾಕ್ ಬಿಡುಗಡೆಯಾಗುವವರೆಗೆ ಕಾಯುತ್ತದೆ, ಲಾಕ್ ಅನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ, ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ಲಾಕ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ. ಇದು ಒಂದು ಸಮಯದಲ್ಲಿ ಕೇವಲ ಒಂದು ಕಾರ್ಯಾಚರಣೆ ಮಾತ್ರ Map ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ರೇಸ್ ಕಂಡೀಶನ್‌ಗಳನ್ನು ತಡೆಯುತ್ತದೆ.

ಪ್ರಮುಖ ಸೂಚನೆ: ಇದು ಅತ್ಯಂತ ಮೂಲಭೂತ ಉದಾಹರಣೆಯಾಗಿದ್ದು, ಇದನ್ನು ಪ್ರೊಡಕ್ಷನ್ ಪರಿಸರದಲ್ಲಿ ಬಳಸಬಾರದು. ಇದು ಅತ್ಯಂತ ಅಸಮರ್ಥ ಮತ್ತು ಡೆಡ್‌ಲಾಕ್‌ಗಳಂತಹ ಸಮಸ್ಯೆಗಳಿಗೆ ಗುರಿಯಾಗಬಹುದು. ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸೆಮಾಫೋರ್‌ಗಳು ಅಥವಾ ಮ್ಯೂಟೆಕ್ಸ್‌ಗಳಂತಹ ಹೆಚ್ಚು ದೃಢವಾದ ಲಾಕಿಂಗ್ ಯಾಂತ್ರಿಕತೆಗಳನ್ನು ಬಳಸಬೇಕು.

ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಹಲವಾರು ಸವಾಲುಗಳನ್ನು ಒಡ್ಡುತ್ತದೆ:

• ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಸ್ವಭಾವ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಭೂತವಾಗಿ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಆಗಿದೆ, ಇದು ಸಾಧಿಸಬಹುದಾದ ನಿಜವಾದ ಪ್ಯಾರಲಲಿಸಂನ ಮಟ್ಟವನ್ನು ಸೀಮಿತಗೊಳಿಸುತ್ತದೆ. ವೆಬ್ ವರ್ಕರ್ಸ್ ಈ ಮಿತಿಯನ್ನು ತಪ್ಪಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಆದರೆ ಅವು ಹೆಚ್ಚುವರಿ ಸಂಕೀರ್ಣತೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ.
• ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಓವರ್‌ಹೆಡ್: ಲಾಕಿಂಗ್ ಯಾಂತ್ರಿಕತೆಗಳು ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ, ಇದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸದಿದ್ದರೆ ಕನ್ಕರೆನ್ಸಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಯೋಜನಗಳನ್ನು ನಿರಾಕರಿಸಬಹುದು.
• ಸಂಕೀರ್ಣತೆ: ಕನ್ಕರೆಂಟ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಅಂತರ್ಗತವಾಗಿ ಸಂಕೀರ್ಣವಾಗಿದೆ ಮತ್ತು ಕನ್ಕರೆನ್ಸಿ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಸಂಭಾವ್ಯ ಅಪಾಯಗಳ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅಗತ್ಯವಿರುತ್ತದೆ.
• ಡೀಬಗ್ ಮಾಡುವುದು: ಕನ್ಕರೆಂಟ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಅನಿರ್ದಿಷ್ಟ ಸ್ವಭಾವದಿಂದಾಗಿ ಕನ್ಕರೆಂಟ್ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದಕ್ಕಿಂತ ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚು ಸವಾಲಿನದ್ದಾಗಿರಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ಗಳ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ಗಳು ಹಲವಾರು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಮೌಲ್ಯಯುತವಾಗಿರಬಹುದು:

• ಕ್ಯಾಶಿಂಗ್: ಅನೇಕ ಥ್ರೆಡ್‌ಗಳು ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭಗಳಿಂದ ಪ್ರವೇಶಿಸಬಹುದಾದ ಮತ್ತು ಅಪ್‌ಡೇಟ್ ಮಾಡಬಹುದಾದ ಕನ್ಕರೆಂಟ್ ಕ್ಯಾಶ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.
• ಡೇಟಾ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ: ನೈಜ-ಸಮಯದ ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಂತಹ ಅನೇಕ ಮೂಲಗಳಿಂದ ಏಕಕಾಲದಲ್ಲಿ ಡೇಟಾವನ್ನು ಒಟ್ಟುಗೂಡಿಸುವುದು.
• ಟಾಸ್ಕ್ ಕ್ಯೂಗಳು: ಅನೇಕ ವರ್ಕರ್‌ಗಳಿಂದ ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದಾದ ಕಾರ್ಯಗಳ ಕ್ಯೂ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು.
• ಗೇಮ್ ಅಭಿವೃದ್ಧಿ: ಮಲ್ಟಿಪ್ಲೇಯರ್ ಆಟಗಳಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಆಟದ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು.

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ಗಳಿಗೆ ಪರ್ಯಾಯಗಳು

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು, ಪರ್ಯಾಯ ವಿಧಾನಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವೇ ಎಂದು ಪರಿಗಣಿಸಿ:

• ಇಮ್ಮ್ಯೂಟಬಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು: ಇಮ್ಮ್ಯೂಟಬಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು ಡೇಟಾವನ್ನು ರಚಿಸಿದ ನಂತರ ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಲಾಕಿಂಗ್ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸಬಹುದು. Immutable.js ನಂತಹ ಲೈಬ್ರರಿಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಇಮ್ಮ್ಯೂಟಬಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.
• ಸಂದೇಶ ರವಾನೆ: ಥ್ರೆಡ್‌ಗಳು ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭಗಳ ನಡುವೆ ಸಂವಹನ ನಡೆಸಲು ಸಂದೇಶ ರವಾನೆಯನ್ನು ಬಳಸುವುದರಿಂದ ಹಂಚಿಕೆಯಾದ ಮ್ಯೂಟಬಲ್ ಸ್ಟೇಟ್‌ನ ಅಗತ್ಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪಿಸಬಹುದು.
• ಗಣನೆಯನ್ನು ಆಫ್‌ಲೋಡ್ ಮಾಡುವುದು: ಗಣನಾತ್ಮಕವಾಗಿ ತೀವ್ರವಾದ ಕಾರ್ಯಗಳನ್ನು ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಗಳು ಅಥವಾ ಕ್ಲೌಡ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಆಫ್‌ಲೋಡ್ ಮಾಡುವುದರಿಂದ ಮುಖ್ಯ ಥ್ರೆಡ್ ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ರೆಸ್ಪಾನ್ಸಿವ್‌ನೆಸ್ ಅನ್ನು ಸುಧಾರಿಸಬಹುದು.

ತೀರ್ಮಾನ

ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ಯಾರಲಲ್ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಪ್ರಬಲವಾದ ಸಾಧನವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಿಂಗಲ್-ಥ್ರೆಡೆಡ್ ಸ್ವಭಾವ ಮತ್ತು ಕನ್ಕರೆನ್ಸಿಯ ಸಂಕೀರ್ಣತೆಯಿಂದಾಗಿ ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸವಾಲುಗಳನ್ನು ಒಡ್ಡಿದರೂ, ಅವು ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಅಥವಾ ಅಸಿಂಕ್ರೊನಸ್ ಪರಿಸರಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು. ವಿನಿಮಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಪರ್ಯಾಯ ವಿಧಾನಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚು ದಕ್ಷ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಕನ್ಕರೆಂಟ್ ಮ್ಯಾಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.

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

ಹೆಚ್ಚಿನ ಅನ್ವೇಷಣೆ

• ವೆಬ್ ವರ್ಕರ್ಸ್ API: MDN ವೆಬ್ ಡಾಕ್ಸ್
• SharedArrayBuffer ಮತ್ತು Atomics: MDN ವೆಬ್ ಡಾಕ್ಸ್
• Immutable.js: ಅಧಿಕೃತ ವೆಬ್‌ಸೈಟ್