JS Atomics

Atomics obyekti

Atomics obyekti umumiy xotira ustida quyi darajadagi atomar amallarni taqdim etadi.

U SharedArrayBuffer va Yozilgan Arraylar bilan ishchilar o‘rtasida ma’lumotlarni almashish uchun ishlatiladi.

Atomics nima?

Bir nechta mavzular (masalan, asosiy oqim va bir yoki bir nechta ishchi) bir xil ma’lumotlarga kirganda, siz poyga shartlarini olishingiz mumkin. Atom quyidagi operatsiyalarni amalga oshirish orqali ushbu poyga sharoitlaridan qochishga yordam beradi:

Umumiy tiplangan massivlar ustida ishlaydi
Atomar tarzda bajariladi (yarim yo‘lda to‘xtatib bo‘lmaydi)
Elementning oldingi qiymatini qaytaring

Atomics obyekti Atomics.load(), Atomics.store(), Atomics.add() va boshqa statik metodlarga ega global obyekt (Math kabi).

Atomics — ilg‘or darajadagi imkoniyat.

Siz odatda Atomics bilan ishlaganingizda foydalanasiz:

Web Workers
Worker Threads
Shared memory

Requirements

Atomics’dan foydalanish uchun sizga kerak:

A SharedArrayBuffer
Umumiy buferdan foydalanadigan tiplangan massiv (masalan, Int32Array)
Xuddi shu buferni baham ko‘radigan bir yoki bir nechta ishchi (yoki iplar).

Xavfsizlik: Vebda SharedArrayBuffer yoqilishi uchun brauzerlar maxsus HTTP sarlavhalarini (masalan, COOP/COEP) talab qilishi mumkin.

Atomics’dan asosiy foydalanish

Misol: umumiy tiplangan massiv yaratish

Umumiy bufer va umumiy butun sonlar massivini yaratish:

const buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);

// Shared integer array with 4 elements
const sharedArray = new Int32Array(buffer);

// Initialize the array
sharedArray[0] = 10;
sharedArray[1] = 20;
sharedArray[2] = 30;
sharedArray[3] = 40;

O‘zingiz sinab ko‘ring »

Atomar o‘qish va yozish

o‘qish va Atomics.store() uchun Atomics.load() dan foydalaning umumiy yozilgan massivdagi elementni yozish uchun.

Misol: Atomics.load() va Atomics.store()

var buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);
var sharedArray = new Int32Array(buffer);

// Store a value atomically
Atomics.store(sharedArray, 0, 123);

// Load the value atomically
var value = Atomics.load(sharedArray, 0);

console.log("Value:", value); // Value: 123

Atomics.store() siz saqlagan qiymatni qaytaradi.

Atomics.load() elementning joriy qiymatini qaytaradi.

Atomar qo‘shish va ayirish

Atomics.add() va Atomics.sub() qiymatni o‘zgartiradi va eski qiymatni qaytaring.

Misol: Atomics.add()

var buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);
var sharedArray = new Int32Array(buffer);

sharedArray[0] = 5;

var oldValue = Atomics.add(sharedArray, 0, 3);

console.log("Old:", oldValue); // Old: 5
console.log("New:", sharedArray[0]);// New: 8

Misol: Atomics.sub()

var buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);
var sharedArray = new Int32Array(buffer);

sharedArray[0] = 10;

var oldValue = Atomics.sub(sharedArray, 0, 4);

console.log("Old:", oldValue); // Old: 10
console.log("New:", sharedArray[0]);// New: 6

Atom almashinuvi va solishtiring

Atomics.exchange() yangi qiymat o‘rnatadi va eskisini qaytaradi. Atomics.compareExchange() faqat joriy bo‘lsa, yangi qiymatni o‘rnatadi qiymat berilgan kutilgan qiymatga teng.

Misol: Atomics.exchange()

var buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);
var sharedArray = new Int32Array(buffer);

sharedArray[0] = 1;

var oldValue = Atomics.exchange(sharedArray, 0, 99);

console.log("Old:", oldValue); // Old: 1
console.log("New:", sharedArray[0]); // New: 99

Misol: Atomics.compareExchange()

var buffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT);
var sharedArray = new Int32Array(buffer);

sharedArray[0] = 10;

// Only replace 10 with 20 if the current value is 10
var oldValue = Atomics.compareExchange(sharedArray, 0, 10, 20);

console.log("Old:", oldValue); // Old: 10
console.log("New:", sharedArray[0]); // New: 20

// Now it will NOT change because the expected value does not match
oldValue = Atomics.compareExchange(sharedArray, 0, 10, 30);

console.log("Old:", oldValue); // Old: 20
console.log("New:", sharedArray[0]); // New: 20

Atomics.wait() va Atomics.notify()

Atomics.wait() (worker’larda) oqimni ma’lum pozitsiyadagi qiymat o‘zgarguncha uyqu holatiga o‘tkazishi mumkin, Atomics.notify() esa bir yoki bir nechta uxlayotgan oqimni uyg‘otadi.

Muhim: Brauzerlarda Atomics.wait() faqat worker kontekstlarida (asosiy oqimda emas) ishlatilishi mumkin.

Misol: Ishchi qiymatni kutmoqda

Main thread (simplified):

// main.js
var buffer = new SharedArrayBuffer(4);
var sharedArray = new Int32Array(buffer);

sharedArray[0] = 0;

var worker = new Worker("worker.js");

// Send the shared buffer to the worker
worker.postMessage(buffer);

// Simulate some work, then set the value and notify the worker
setTimeout(function() {
Atomics.store(sharedArray, 0, 1);
Atomics.notify(sharedArray, 0, 1); // wake 1 worker
}, 1000);

Worker (worker.js):

// worker.js
onmessage = function(e) {
  var buffer = e.data;
  var sharedArray = new Int32Array(buffer);

  console.log("Worker waiting...");
  var result = Atomics.wait(sharedArray, 0, 0); // wait while value is 0

  console.log("Worker woken, result =", result);
  console.log("New value:", Atomics.load(sharedArray, 0));
};

To‘liq Atomics ma’lumotnomasi

Qayta ko‘rib chiqilgan: 2025-yil dekabr

Metod	Tavsif
load(typedArray, index)	Indeksdagi qiymatni o‘qiydi va qaytaradi.
store(typedArray, index, value)	Qiymatni indeksda saqlaydi va uni qaytaradi.
add(typedArray, index, value)	Elementga qiymat qo‘shadi va eski qiymatni qaytaradi.
sub(typedArray, index, value)	Qiymatni ayiradi va eski qiymatni qaytaradi.
and(typedArray, index, value)	Bit bo‘yicha AND qiymati bilan bajaradi va eski qiymatni qaytaradi.
or(typedArray, index, value)	Bit bo‘yicha OR qiymati bilan bajaradi va eski qiymatni qaytaradi.
xor(typedArray, index, value)	Bit bo‘yicha XORni qiymat bilan bajaradi va eski qiymatni qaytaradi.
exchange(typedArray, index, value)	Indeksdagi qiymatni almashtiradi va eski qiymatni qaytaradi.
compareExchange(typedArray, index, expected, value)	Agar joriy qiymat kutilsa, indeksdagi qiymatni qiymat bilan almashtiradi. Eski qiymatni qaytaradi.
wait(typedArray, index, value, timeout?)	(Faqat ishchi) Element o‘zgarmaguncha yoki vaqt tugamaguncha chaqiruvchi ipni bloklaydi.
notify(typedArray, index, count)	Indeksni kutayotgan uxlab yotgan iplarni uyg‘otadi.

Atomics umumiy xotira orqali oqimlar o‘rtasidagi aloqa uchun mo‘ljallangan
Siz ularni SharedArrayBuffer va Typed Arrays bilan ishlatasiz
Atom operatsiyalarini boshqa iplar bilan to‘xtatib bo‘lmaydi
Atomics’dan faqat quyi darajadagi sinxronizatsiya kerak bo‘lganda foydalaning
Ko‘pchilik JavaScript kodiga Atomics kerak emas

Batafsil bilib oling:

Typed Array Tutorial

Typed Array Methods

Typed Array Reference

Array Buffers

DataViews

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish