자바스크립트에서도 동기화 문제가 발생할까?

초기 합계: 10
producer, consumer 스레드 실행 이후 합계: -38292

프로세스A         프로세스B      현재 sum   현재 r1   현재 r2
-------------------------------------------------------------
r1 = sum                     |   10        10
r1 = r1 + 1                  |   10        11
문맥교환                      |   10        11
                 r2 = sum    |   10        11        10
                 r2 = r2 -1  |   10        11         9
                 문맥교환     |   10        11         9
sum = r1                     |   11        11         9
문맥 교환                     |   11        11         9
                 sum = r2    |    9        11         9

초기 합계:  10
producer, consumer 스레드 실행 이후 합계:  10

순서: 1
실행 내용: let sum = 10;
변수 상태 (sum): sum = 10

순서: 2
실행 내용: main() 함수 호출
변수 상태 (sum): sum = 10

순서: 3
실행 내용: console.log("초기 합계: ", sum); → 초기값 10 출력
변수 상태 (sum): sum = 10

순서: 4
실행 내용: producer() 실행
           - for 루프: 반복마다 sum += 1 수행
           - 최종적으로 1,000,000번 반복하여 10 + 1,000,000 = 1,000,010
변수 상태 (sum): sum = 1,000,010

순서: 5
실행 내용: consumer() 실행
           - for 루프: 반복마다 sum -= 1 수행
           - 최종적으로 1,000,010 - 1,000,000 = 10
변수 상태 (sum): sum = 10

순서: 6
실행 내용: console.log("producer, consumer 스레드 실행 이후 합계: ", sum); → 최종값 10 출력
변수 상태 (sum): sum = 10

초기 합계:  10
Consumer 작업 완료
Producer 작업 완료
producer, consumer 스레드 실행 이후 합계:  -844
예상 합계(10)와 실제 합계의 차이: -854

Atomic.wat(typedArray, index, value);
Atomic.nofity(typedArray, index, count);

소비: 카운터 = 11, 소비 = 999
소비: 카운터 = 10, 소비 = 1000
Consumer 작업 완료
producer, consumer 스레드 실행 이후 합계:  10
예상 합계(10)와 실제 합계의 차이: 0

let sum = 10;
function producer() {
  for (let i = 0; i < 1000000; i++) {
    sum += 1;
  }
}

function consumer() {
  for (let i = 0; i < 1000000; i++) {
    sum -= 1;
  }
}

function main() {
  console.log("초기 합계: ", sum);
  producer();
  consumer();
  console.log("producer, consumer 스레드 실행 이후 합계: ", sum);
}

main();

//worker.js
import { Worker } from "node:worker_threads";
import path from "node:path";

const INIT_VALUE = 10;
console.log("초기 합계: ", INIT_VALUE);

const sharedBuffer = new SharedArrayBuffer(4);
const counter = new Int32Array(sharedBuffer);
counter[0] = INIT_VALUE;

const producer = new Worker(path.resolve(__dirname, "producer.js"), {
  workerData: { sharedBuffer },
});

const consumer = new Worker(path.resolve(__dirname, "consumer.js"), {
  workerData: { sharedBuffer },
});

let completedWorkers = 0;
function checkCompletion() {
  completedWorkers++;
  if (completedWorkers === 2) {
    console.log("producer, consumer 스레드 실행 이후 합계: ", counter[0]);
    console.log("예상 합계(10)와 실제 합계의 차이:", counter[0] - 10);
  }
}

producer.on("message", (message) => {
  console.log(message);
  checkCompletion();
});

consumer.on("message", (message) => {
  console.log(message);
  checkCompletion();
});

import { parentPort, workerData } from "worker_threads";
const sharedBuffer = workerData.sharedBuffer;
const counter = new Int32Array(sharedBuffer);

function consumer() {
  for (let i = 0; i < 1000; i++) {
    const currentValue = Atomics.load(counter, 0);
    const start = Date.now();
    while (Date.now() - start < 1) {}
    Atomics.store(counter, 0, currentValue - 1);
  }
}
consumer();
parentPort.postMessage("Consumer 작업 완료");

//worker.js
const sharedBuffer = new SharedArrayBuffer(4 * 3);
const counter = new Int32Array(sharedBuffer);

// 초기화: 카운터 = 0, 생산된 아이템 = 0, 소비된 아이템 = 0
counter[0] = 0;
counter[1] = 0;
counter[2] = 0;

// producer.js
while (Atomics.load(counter, 1) - Atomics.load(counter, 2) >= MAX_BUFFER_SIZE) {
  Atomics.wait(counter, 2, Atomics.load(counter, 1));
}

// consumer.js
while (Atomics.load(counter, 1) <= Atomics.load(counter, 2)) {
  Atomics.wait(counter, 1, Atomics.load(counter, 1));
}

//producer.js
import { parentPort, workerData } from "worker_threads";

const sharedBuffer = workerData.sharedBuffer;
const counter = new Int32Array(sharedBuffer);
const MAX_BUFFER_SIZE = 10;

function producer() {
  for (let i = 0; i < 1000; i++) {
    while (
      Atomics.load(counter, 1) - Atomics.load(counter, 2) >=
      MAX_BUFFER_SIZE
    ) {
      Atomics.wait(counter, 2, Atomics.load(counter, 1));
    }

    const start = Date.now();
    while (Date.now() - start < 1) {}
    Atomics.add(counter, 0, 1);
    const producedItems = Atomics.add(counter, 1, 1) + 1;
    console.log(
      `생산: 카운터 = ${Atomics.load(counter, 0)}, 생산 = ${producedItems}`
    );
    Atomics.notify(counter, 1, 1);
  }
}

producer();
parentPort.postMessage("Producer 작업 완료");

// consumer.js
import { parentPort, workerData } from "worker_threads";

const sharedBuffer = workerData.sharedBuffer;
const counter = new Int32Array(sharedBuffer);

function consumer() {
  for (let i = 0; i < 1000; i++) {
    while (Atomics.load(counter, 1) <= Atomics.load(counter, 2)) {
      Atomics.wait(counter, 1, Atomics.load(counter, 1));
    }
    const start = Date.now();
    while (Date.now() - start < 1) {}

    Atomics.sub(counter, 0, 1);
    const consumedItems = Atomics.add(counter, 2, 1) + 1;
    console.log(
      `소비: 카운터 = ${Atomics.load(counter, 0)}, 소비 = ${consumedItems}`
    );
    Atomics.notify(counter, 2, 1);
  }
}
consumer();
parentPort.postMessage("Consumer 작업 완료");

#include <iostream>
#include <queue>
#include <thread>

void produce();
void consume();

int sum = 10;
void produce() {
  for(int i = 0; i < 100000; i++) {
    sum++;
  }
}

void consume() {
  for(int i = 0; i < 100000; i++) {
    sum--;
  }
}

int main() {
  std::cout << "초기 합계: " <<  sum << std::endl;
  std::thread producer(produce);
  std::thread consumer(consume);

  producer.join();
  consumer.join();
  std::cout << "producer, consumer 스레드 실행 이후 합계: " <<  sum << std::endl;
  return 0;
}

struct SharedBuffer
{
  std::queue<int> buffer;
  std::mutex mutex;
  std::condition_variable not_full;
  std::condition_variable not_empty;
  const int capacity = 10;
  int counter = 0;
};

std::unique_lock<std::mutex> lock(buffer.mutex);

buffer.not_full.wait(lock, [&buffer]() {
	return buffer.buffer.size() < buffer.capacity;
});

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

struct SharedBuffer
{
  std::queue<int> buffer;
  std::mutex mutex;
  std::condition_variable not_full;
  std::condition_variable not_empty;
  const int capacity = 10;
  int counter = 0;
};

void producer(SharedBuffer& buffer, int items) {
  for (int i = 0; i < items; i++) {
      // 임계 영역 진입
      std::unique_lock<std::mutex> lock(buffer.mutex);
      // 버퍼가 가득 찼으면 대기
      buffer.not_full.wait(lock, [&buffer]() {
          return buffer.buffer.size() < buffer.capacity;
      });
      // 버퍼에 아이템 추가 및 카운터 증가
      buffer.buffer.push(i);
      buffer.counter++;
      std::cout << "생산: 아이템 " << i << ", 카운터 = " << buffer.counter << std::endl;
      // 소비자에게 버퍼가 비어있지 않음을 알림
      buffer.not_empty.notify_one();
      // 임계 영역 나가기 (lock 소멸자에서 자동으로 발생)
  }
}

void consumer(SharedBuffer& buffer, int items) {
    for (int i = 0; i < items; i++) {
        // 임계 영역 진입
        std::unique_lock<std::mutex> lock(buffer.mutex);
        // 버퍼가 비었으면 대기
        buffer.not_empty.wait(lock, [&buffer]() {
            return !buffer.buffer.empty();
        });
        // 버퍼에서 아이템 제거 및 카운터 감소
        int item = buffer.buffer.front();
        buffer.buffer.pop();
        buffer.counter--;
        std::cout << "소비: 아이템 " << item << ", 카운터 = " << buffer.counter << std::endl;
        // 생산자에게 버퍼가 가득 차지 않았음을 알림
        buffer.not_full.notify_one();
        // 임계 영역 나가기 (lock 소멸자에서 자동으로 발생)
    }
}

int main() {
  SharedBuffer buffer;
  std::thread producerThread(producer, std::ref(buffer), 100);
  std::thread consumerThread(consumer, std::ref(buffer), 100);
  producerThread.join();
  consumerThread.join();
  std::cout << "최종 카운터 값: " << buffer.counter << std::endl;
  return 0;
}