单线程和异步
- JS是单线程的，无论在浏览器还是在nodejs
- 浏览器中JS执行和DOM渲染共用一个线程，是互斥的
- 异步是单线程的解决方案
1. 浏览器中的事件循环 异步里面分宏任务和微任务
-
宏任务：setTimeout，setInterval，setImmediate，I/O，UI渲染，网络请求
-
微任务：Promise，process.nextTick，MutationObserver、async/await
-
宏任务和微任务的区别：微任务的优先级高于宏任务，微任务会在当前宏任务执行完毕后立即执行，而宏任务会在下一个事件循环中执行
-
- 宏任务在页面渲染之后执行
- 微任务在页面渲染之前执行
- 也就是微任务在下一轮DOM渲染之前执行，宏任务在DOM渲染之后执行
1console.log('start')
2setTimeout(() => {
3 console.log('timeout')
4})
5Promise.resolve().then(() => {
6 console.log('promise then')
7})
8console.log('end')
9
10
11
12
13
14
1
2
3
4
5
6
7
8const MarcoTaskQueue = [
9 () => {
10 console.log('timeout')
11 },
12 fn
13]
14
15ajax(url, fn)
16
17
18
19
20
21const MicroTaskQueue = [
22 () => {
23 console.log('promise then')
24 }
25]
26
27
1<p>Event Loop</p>
2
3<script>
4 const p = document.createElement('p')
5 p.innerHTML = 'new paragraph'
6 document.body.appendChild(p)
7 const list = document.getElementsByTagName('p')
8 console.log('length----', list.length)
9
10 console.log('start')
11
12 setTimeout(() => {
13 const list = document.getElementsByTagName('p')
14 console.log('length on timeout----', list.length)
15 alert('阻塞 timeout')
16 })
17
18 Promise.resolve().then(() => {
19 const list = document.getElementsByTagName('p')
20 console.log('length on promise.then----', list.length)
21 alert('阻塞 promise')
22 })
23 console.log('end')
24</script>
2. nodejs中的事件循环
- nodejs也是单线程，也需要异步
- 异步任务也分为：宏任务 + 微任务
- 但是，它的宏任务和微任务分为不同的类型，有不同的优先级
- 和浏览器的主要区别就是类型和优先级，理解了这里就理解了nodejs的事件循环
宏任务类型和优先级
类型分为6个，优先级从高到底执行
- Timer：setTimeout、setInterval
- I/O callbacks：处理网络、流、TCP的错误回调
- Idle,prepare：闲置状态（nodejs内部使用）
- Poll轮询：执行poll中的I/O队列
- Check检查：存储setImmediate回调
- Close callbacks：关闭回调，如socket.on(‘close’)
注意：process.nextTick优先级最高，setTimeout比setImmediate优先级高
执行过程
- 执行同步代码
- 执行微任务（process.nextTick优先级最高）
- 按顺序执行6个类型的宏任务（每个开始之前都执行当前的微任务）
总结
- 浏览器和nodejs的事件循环流程基本相同
- nodejs宏任务和微任务分类型，有优先级。浏览器里面的宏任务和微任务是没有类型和优先级的
- node17之后推荐使用setImmediate代替process.nextTick（如果使用process.nextTick执行复杂任务导致后面的卡顿就得不偿失了，尽量使用低优先级的api去执行异步）
1console.info('start')
2setImmediate(() => {
3 console.info('setImmediate')
4})
5setTimeout(() => {
6 console.info('timeout')
7})
8Promise.resolve().then(() => {
9 console.info('promise then')
10})
11process.nextTick(() => {
12 console.info('nextTick')
13})
14console.info('end')
15
16
17
18
19
20
21
22
nodejs如何开启多进程，进程如何通讯
进程process和线程thread的区别
- 进程，OS进行资源分配和调度的最小单位，有独立的内存空间
- 线程，OS进程运算调度的最小单位，共享进程内存空间
- JS是单线程的，但可以开启多进程执行，如WebWorker
为何需要多进程
-
多核CPU，更适合处理多进程
-
内存较大，多个进程才能更好利用（单进程有内存上限）
-
总之，压榨机器资源，更快、更节省 如何开启多进程
-
开启子进程 child_process.fork和cluster.fork
-
- child_process.fork用于单个计算量较大的计算
- cluster用于开启多个进程，多个服务
-
使用send和on传递消息 使用child_process.fork方式
1const http = require('http')
2const fork = require('child_process').fork
3
4const server = http.createServer((req, res) => {
5 if (req.url === '/get-sum') {
6 console.info('主进程 id', process.pid)
7
8
9 const computeProcess = fork('./compute.js')
10 computeProcess.send('开始计算')
11
12 computeProcess.on('message', data => {
13 console.info('主进程接收到的信息：', data)
14 res.end('sum is ' + data)
15 })
16
17 computeProcess.on('close', () => {
18 console.info('子进程因报错而退出')
19 computeProcess.kill()
20 res.end('error')
21 })
22 }
23})
24server.listen(3000, () => {
25 console.info('localhost: 3000')
26})
1
2
3
4 * @description 子进程，计算
5 */
6
7function getSum() {
8 let sum = 0
9 for (let i = 0; i < 10000; i++) {
10 sum += i
11 }
12 return sum
13}
14
15process.on('message', data => {
16 console.log('子进程 id', process.pid)
17 console.log('子进程接收到的信息: ', data)
18
19 const sum = getSum()
20
21
22 process.send(sum)
23})
使用cluster方式
1const http = require('http')
2const cpuCoreLength = require('os').cpus().length
3const cluster = require('cluster')
4
5
6if (cluster.isMaster) {
7 for (let i = 0; i < cpuCoreLength; i++) {
8 cluster.fork()
9 }
10
11 cluster.on('exit', worker => {
12 console.log('子进程退出')
13 cluster.fork()
14 })
15} else {
16
17 const server = http.createServer((req, res) => {
18 res.writeHead(200)
19 res.end('done')
20 })
21 server.listen(3000)
22}
23
24
25
个人笔记记录 2021 ~ 2025