【聊聊原子性，中断，以及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}`)// rlet 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}`)// rlet resultCopy = result;// 让出cpuawait 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等待 都不能被切出。这段代码需要完整的执行，这才是我们预期的一段代码的原子性。