SharedArrayBuffer와 Atomics — 멀티스레드 공유 메모리

// 일반 ArrayBuffer — 전송 시 복사 또는 소유권 이전
const buffer = new ArrayBuffer(1024);
worker.postMessage(buffer, [buffer]); // Transferable: 소유권 이전
console.log(buffer.byteLength); // 0 — 더 이상 접근 불가

// SharedArrayBuffer — 공유! 복사 없음
const sharedBuffer = new SharedArrayBuffer(1024);
worker.postMessage(sharedBuffer); // 복사 없이 공유
console.log(sharedBuffer.byteLength); // 1024 — 여전히 접근 가능

Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp

// 브라우저에서 확인
if (typeof SharedArrayBuffer !== "undefined") {
  console.log("SharedArrayBuffer 사용 가능");
}
// self.crossOriginIsolated가 true여야 함
console.log(self.crossOriginIsolated);

// 메인 스레드
const sharedBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 10);
const sharedArray = new Int32Array(sharedBuffer);

// 초기값 설정
sharedArray[0] = 42;

// 워커에 공유
worker.postMessage(sharedBuffer);

// worker.js
self.addEventListener("message", (e) => {
  const sharedArray = new Int32Array(e.data);
  console.log(sharedArray[0]); // 42 — 메인 스레드의 데이터 직접 접근
  sharedArray[0] = 100;        // 메인 스레드에서도 변경 반영
});

// 두 워커가 동시에 sharedArray[0]++를 실행하면?
// 읽기 → 증가 → 쓰기가 원자적이지 않으므로
// 값이 손실될 수 있음 (Lost Update)

// sharedArray[0] = 0 일 때
// Worker A: 읽기(0) → 증가(1) → 쓰기(1)
// Worker B: 읽기(0) → 증가(1) → 쓰기(1)
// 결과: 1 (기대값 2)

const sharedArray = new Int32Array(sharedBuffer);

// 원자적 읽기/쓰기
Atomics.store(sharedArray, 0, 42);     // 원자적 쓰기
const value = Atomics.load(sharedArray, 0); // 원자적 읽기

// 원자적 증가/감소
Atomics.add(sharedArray, 0, 1);  // sharedArray[0] += 1 (원자적)
Atomics.sub(sharedArray, 0, 1);  // sharedArray[0] -= 1 (원자적)

// 원자적 비트 연산
Atomics.and(sharedArray, 0, 0xFF);
Atomics.or(sharedArray, 0, 0x80);
Atomics.xor(sharedArray, 0, 0x01);

// 원자적 교환
const old = Atomics.exchange(sharedArray, 0, 99); // 이전 값 반환

// 원자적 비교 후 교환 (CAS)
Atomics.compareExchange(sharedArray, 0, 99, 100);
// sharedArray[0]이 99이면 100으로 교환, 아니면 변경 없음

// Worker (대기 측)
const sharedArray = new Int32Array(sharedBuffer);
console.log("데이터 대기 중...");
Atomics.wait(sharedArray, 0, 0); // sharedArray[0]이 0인 동안 대기
console.log("깨어남! 값:", Atomics.load(sharedArray, 0));

// 메인 스레드 (알림 측)
Atomics.store(sharedArray, 0, 42);  // 값 변경
Atomics.notify(sharedArray, 0, 1);  // 대기 중인 워커 1개 깨우기

class Mutex {
  constructor(sharedArray, index = 0) {
    this.sharedArray = sharedArray;
    this.index = index;
  }

  lock() {
    // 0이면 1로 바꾸고 진행 (잠금 획득)
    while (Atomics.compareExchange(this.sharedArray, this.index, 0, 1) !== 0) {
      // 이미 잠겨있으면 대기
      Atomics.wait(this.sharedArray, this.index, 1);
    }
  }

  unlock() {
    Atomics.store(this.sharedArray, this.index, 0);
    Atomics.notify(this.sharedArray, this.index, 1);
  }
}

// 워커에서 사용
const mutex = new Mutex(new Int32Array(sharedBuffer));

mutex.lock();
// 임계 구역 — 안전하게 공유 데이터 수정
sharedData[1] += 1;
mutex.unlock();

// 메인 스레드
const size = 1_000_000;
const buffer = new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * size);
const array = new Float64Array(buffer);

// 데이터 초기화
for (let i = 0; i < size; i++) array[i] = i;

// 4개 워커에 분할
const workerCount = 4;
const chunkSize = size / workerCount;

for (let i = 0; i < workerCount; i++) {
  const worker = new Worker("compute.js");
  worker.postMessage({
    buffer,
    start: i * chunkSize,
    end: (i + 1) * chunkSize,
  });
}

// compute.js
self.addEventListener("message", (e) => {
  const { buffer, start, end } = e.data;
  const array = new Float64Array(buffer);

  for (let i = start; i < end; i++) {
    array[i] = Math.sqrt(array[i]); // 각 워커가 자기 구간만 처리
  }

  self.postMessage("done");
});