【聊聊原子性，中断，以及nodejs中的具体示例】

什么是原子性

从一个例子说起， x++ ，读和写 ，

如图假设多线程，线程1和线程2同时操作变量x，进行x++的操作，那么由于写的过程中，都会先读一份x数据到cpu的寄存器中，所以这个时候cpu1 和 cpu2 拿到了相同的变量x，假设初始x值为1，则cpu1拿到的x为1，cpu2拿到的x为1，都操作并写回给x后，x的值为2。

预期加两次，结果为3，但是实际由于多线程同时操作同一个变量了 ，可能产生写覆盖。进一步看，这其中还要再提起一个词，中断。

中断

多线程 - cpu中断

多线程下，常见一个或者多个操作在 CPU 执行时候，中断，切出再切回。

对于多线程来说，程序在运行一段代码的时候，可能会中途切出，这种来回切出和切回，就出现了上面x++的情况。产生了写覆盖的问题。

那么不用多线程，只用单线程，是不是就不会存在中断的问题，是不是就安全了，其实也不安全。因为线程下面还有协程（如python Coroutine），或如nodejs中 event loop，其虽然不会在cpu运算的时候切出，但是会在等待io的时候切出。

单线程 - io中断

单线程下，一个或者多个IO操作执行的过程中，中断，切出再切回。

一个单线程切出的例子，拿nodejs中event loop举例，worker1 和 worker2分别产生event，去累加result，但是在累加的过程中会await sleep 模拟等待io，这会导致由于等待io而引起的中断，切出。

非原子性示例

function sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

let result = 0;

async function worker1() {
    let maxtime1 = 1;

    while(maxtime1 <= 100) {
        let name = 'worker1';
        // 执行100次)
        console.log(`${name} calculate current time ${maxtime1}`)
        // 开始工作
        let resultCopy = result;
        // 让出
        await sleep(10);
        resultCopy += 1;
        result = resultCopy;

        maxtime1 += 1;
    }
}

async function worker2() {
    let maxtime2 = 1;
    while(maxtime2 <= 100) {
        let name = 'worker2';
        // 执行100次
        console.log(`${name} calculate current time ${maxtime2}`)
        // 开始工作
        let resultCopy = result;
        // 让出
        await sleep(10);
        resultCopy += 1;
        result = resultCopy;

        maxtime2 += 1;
    }
}

(async () => {
    console.log('start calculate')
    const startTime = Date.now();
    Promise.all([worker1(), worker2()]).then(() => {
        const endTime = Date.now();
        // 预期是200 ，但是由于会写覆盖，所以最终小于200.
        console.log(`耗时: ${endTime - startTime}ms`);
        console.log('result:', result);

    }).catch((error) => {
        console.error('A worker failed with error:', error);
    });
})()

运行结果，通过结果 ，甚至输出结果直接就是100，因为worker1 和 worker2的并行执行，导致每次累加计算前，worker1 和 worker2 都拿到相同的值

那么如何避免这种情况，让worker1的代码片段执行完，再执行的worker2的代码片段，不切出，达到原子性，一种方法就是加锁，下面继续看如何加锁达到原子性，

原子性示例

通过加锁，可以实现代码片段的原子性 ，如下

import { Mutex } from 'async-mutex';
const mutex = new Mutex();

function sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

let result = 0;

async function worker1() {
    let maxtime1 = 1;

    // 执行100次
    while(maxtime1 <= 100) {
        let name = 'worker1';
        // 开始工作
        // 锁住,
        const release = await mutex.acquire();
        console.log(`${name} calculate current time ${maxtime1}, before start calulate result: ${result}`)

        // r
        let resultCopy = result;
        // 让出cpu，这里即使让出，其它worker由于无法获取锁，所以会一直等待
        await sleep(10);
        resultCopy += 1;
        // w 
        result = resultCopy;

        console.log(`${name} calculate current time ${maxtime1}, after calulate result: ${result}`)
        release();

        maxtime1 += 1;
    }
}

async function worker2() {
    let maxtime2 = 1;
    // 执行100次
    while(maxtime2 <= 100) {
        let name = 'worker2';

        // 开始工作
        // 锁住,
        const release = await mutex.acquire();
        console.log(`${name} calculate current time ${maxtime2}, before start calulate result: ${result}`)
        // r
        let resultCopy = result;
        // 让出cpu
        await sleep(10);
        resultCopy += 1;
        // w 
        result = resultCopy;

        console.log(`${name} calculate current time ${maxtime2}, after calulate result: ${result}`)
        release();

        maxtime2 += 1;
    }
}

(async () => {
    console.log('start calculate')
    const startTime = Date.now();
    Promise.all([worker1(), worker2()]).then(() => {
        const endTime = Date.now();
        // 预期是200 ，但是由于会写覆盖，所以最终小于200.
        console.log(`耗时: ${endTime - startTime}ms`);
        console.log('result:', result);

    }).catch((error) => {
        console.error('A worker failed with error:', error);
    });
})()

此时，在看输出结果，可以发现由于有锁，worker1 和 worker2是串行累加的，不会在执行累加的过程中切出，所以最终累加的结果是200，符合预期。

同时可以发现，由于加锁，整体串行，会导致整体运行时间增加。这里就不得不多提下，Event Loop 是一种异步编程模型，io切出本身属于提高效率的设计，所以如果不是需要原子性，不是同时操作同一个变量，则没必要加锁降低效率。

结语

总结 ，对于编程中的原子性，如果说一段代码是原子性的，则这段代码无论是cpu 还是 io等待 都不能被切出。这段代码需要完整的执行，这才是我们预期的一段代码的原子性。