基础
node 并发node通过单线程来处理高并发的请求。
一个事件循环中的执行是可以保证并发安全的,但是也业务操作并发读写一样会有业务的并发问题
在 JavaScript 中,函数总是运行到完成。这意味着如果一个函数正在运行,那么它将完全运行; 只有在这之后,才会调用另一个函数。因此,语句之间不存在交织的可能性(但是对于 Java 来说就不同了)。
线程锁:单线程编程模式下请求是顺序的,一个好处是不需要考虑线程安全、资源竞争问题,因此当你进行 Node.js 编程时,也不会去考虑线程安全问题。那么多线程编程模式下,例如 Java 你可能很熟悉一个词 synchronized,通常也是 Java 中解决并发编程最简单的一种方式,synchronized 可以保证在同一时刻仅有一个线程去执行某个方法或某块代码。
进程锁:一个服务部署于一台服务器,同时开启多个进程,Node.js 编程中为了利用操作系统资源,根据 CPU 的核心数可以开启多进程模式,这个时候如果对一个共享资源操作还是会遇到资源竞争问题,另外每一个进程都是相互独立的,拥有自己独立的内存空间。关于进程锁通过 Java 中的 synchronized 也很难去解决,synchronized 仅局限于在同一个 JVM 中有效。
分布式锁:一个服务无论是单线程还是多进程模式,当多机部署、处于分布式环境下对同一共享资源进行操作还是会面临同样的问题。此时就要去引入一个概念分布式锁。如下图所示,由于先读数据在通过业务逻辑修改之后进行 SET 操作,这并不是一个原子操作,当多个客户端对同一资源进行先读后写操作就会引发并发问题,这时就要引入分布式锁去解决,通常也是一个很广泛的解决方案。
Automics
原子性操作
Atomics.add() - JavaScript | MDN
Atomics in JavaScript - GeeksforGeeks
describe('autoMicNumberCount', () => {
const counter = new Int32Array(new SharedArrayBuffer(4));
/**
* @description 任务数量++
* @private
*/
async function handCurrentTaskAdd() {
Atomics.add(counter, 0, 1);
}
/**
* @description 任务数量--
* @private
*/
async function handCurrentTaskSub() {
Atomics.sub(counter, 0, 1);
}
it('autoMicNumberCount test', async () => {
const tasks = [];
for (let i = 0; i < 10000; i++) {
tasks.push(handCurrentTaskAdd());
}
for (let i = 0; i < 9000; i++) {
tasks.push(handCurrentTaskSub());
}
await Promise.all(tasks);
expect(Atomics.load(counter, 0)).toBe(1000);
});
});
Mutex
锁
private readonly mutex = new Mutex();
private currentTaskComplete = 1;
/**
* @description 任务数量++
* @private
*/
private async handCurrentTaskAdd() {
await this.mutex.runExclusive(async () => {
this.currentTaskComplete++;
});
}
/**
* @description 任务数量--
* @private
*/
private async handCurrentTaskSub() {
await this.mutex.runExclusive(async () => {
this.currentTaskComplete--;
});
}
异常并发 case 非原子
describe('autoMicNumberCount', () => {
let a = 1;
async function one() {
return 1;
}
async function example() {
// 操作被分割成了多个步骤,并且由于await one();的存在,中间可能会插入其他操作,这就打破了原子性。
console.log('Adding 1 to a');
a += await one();
// 修改 a++ 最终结果就是一致的
}
it('autoMicNumberCount test', async () => {
console.log(`Start, a = ${a}`);
Promise.all([
example(),
example(),
example(),
])
.then(() => {
console.log(`All done, a = ${a}`);
});
});
});
正常操作 case 原子
对于JavaScript而言,由于它是单线程的(至少在V8引擎中是这样),因此在没有显式使用异步或并发特性的情况下,函数中的操作通常被认为是原子性的。
下面操作测试结果都是正常的,不过这块代码对于性能也没有特别苛刻要求,自己对底层了解还是不太足够没有特别大的把握,使用Automics放心一点吧
describe('autoMicNumberCount', () => {
let count = 0;
/**
* @description 任务数量++
* @private
*/
function handCurrentTaskAdd() {
count++;
}
/**
* @description 任务数量--
* @private
*/
function handCurrentTaskSub() {
count--;
}
it('autoMicNumberCount test', async () => {
const tasks = [];
for (let index = 0; index < 10000; index++) {
tasks.push(handCurrentTaskAdd());
}
for (let index = 0; index < 9000; index++) {
tasks.push(handCurrentTaskSub());
}
await Promise.all(tasks);
expect(count).toBe(1000);
});
});
describe('autoMicNumberCount', () => {
let count = 0;
beforeEach(() => {
// 在每个测试之前启用假定时器
jest.useFakeTimers();
});
afterEach(() => {
// 在每个测试之后恢复真实的定时器
jest.useRealTimers();
});
/**
* @description 任务数量++
* @private
*/
async function handCurrentTaskAdd() {
// 定时器延迟 1 毫秒执行
setTimeout(() => {
count++;
}, 1);
}
/**
* @description 任务数量--
* @private
*/
async function handCurrentTaskSub() {
setTimeout(() => {
count--;
}, 1);
}
it('autoMicNumberCount test', async () => {
const tasks = [];
for (let index = 0; index < 10000; index++) {
tasks.push(handCurrentTaskAdd());
}
for (let index = 0; index < 9000; index++) {
tasks.push(handCurrentTaskSub());
}
await Promise.all(tasks);
// 使用 Jest 的 advanceTimersByTime 方法来推进时间
jest.advanceTimersByTime(100); // 推进足够的时间以确保所有回调都已执行
// 确保所有 setTimeout 回调都已经执行
expect(count).toBe(1000);
});
});