一步步深挖js异步编程

5/20/2020 javascript

# 异步编程 单线程javascript异步方案

# javascript 采用单线程模式执行工作的原因?

与最早的设计初衷有关,JavaScript最早是运行在浏览器上的脚本语言,目的是实现页面上的动态交互,而实现页面交互的核心就是DOM操作,这也就决定了它必须实现单线程模型,否则会出现多线程同步的问题,假设DOM操作是多线程工作,这个修改了DOM,同时那个删除了DOM,这样浏览器就不能决定以哪个结果为准,所以为了避免线程同步的问题,JavaScript被设计成单线程模式工作

JavaScript单线程是指在js执行代码环境当中,负责执行代码的线程只有一个,这种模式的优点是更安全,更简单,缺点是遇到耗时的任务需要等待排队去实现,这会导致整个程序会被拖延出现假死的情况 image

# 同步模式

同步模式指我们代码中的任务必须依次执行,代码中的任务必须等待上一个任务执行完才能执行,程序的执行顺序和代码的编写顺序是完全一致的,这种方式会比较简单,在单线程情况下我们大多数任务都会以同步模式去执行,这里的同步指排队执行

js在执行过程中维护了一个正在执行的工作表,在这里我们会记录他当前做的事情,当工作表中的任务全部清空以后,这轮工作算是结束了

// 同步执行顺序 
//顺序0:首先会加载整体代码,在调用栈中压入一个匿名函数调用 
console.log('start');//顺序1
function bar(){
	console.log('bar');//顺序3
}
function foo(){
	console.log('foo');//顺序2
	bar()
}
foo()
console.log('end');//顺序4

// start
// foo
// bar
// end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这种排队执行的机制存在一个很严重的问题:如果其中某一行代码执行时间过长,后面的任务就会被延迟,那我们把这种延迟称之为阻塞,这种阻塞对于用户而言会有卡顿或卡死,所以需要异步模式来解决编程当中的耗时操作,如浏览器端的ajax或nodejs中的大文件读写

# 异步模式

异步模式不会等待这个任务的结束才开始执行下一个任务,对于耗时操作,它都是开启过后就立即执行下一个任务,耗时任务的后继逻辑都是通过回调函数的方式定义,在内部呢,耗时任务完成过后就会自动执行传入的回调函数

异步模式的重要性:没有异步模式,JavaScript无法处理大规模的耗时任务

相比于同步模式,异步的执行顺序是你不能确定的,跳跃的

// 异步执行顺序
//顺序0:首先会加载整体代码,在调用栈中压入一个匿名函数调用 
console.log('start');//顺序1
// 遇到异步调用,放在web apis中执行
setTimeout(function timer1 (){//注意倒计时器是单独工作的并不受我们的js线程影响
	console.log('timer1');//顺序4
},1800)
setTimeout(function timer1 (){
	console.log('timer2');//顺序3
	setTimeout(function timer1 (){
		console.log('timer3');//顺序5
	},1000)
	
},1000)
console.log('end');//顺序2
// start
// end
// timer2
// timer1
// timer3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  • 事件循环机制负责监听调用栈和消息队列,当调用栈中多有任务都结束后,事件循环机制会从消息队列取出第一个回调函数,然后压入到调用栈,此时的消息队列是空的,程序也就暂停了,等到计时器的倒计时结束后,先结束的timer2会被放在消息队列的第一位,time1放在消息队列的第二位,一但消息队列发生变化,时间循环机制就会监听到,然后把消息队列中的第一个time2压入调用栈,继续执行time2,此时对于调用栈相当于开启了新的执行,执行顺序是一致的,遇到异步调用就放在web api中执行,如此不断重复,直到调用栈和消息队列都没有需要执行的任务了,整体的代码就结束了
  • 如果说调用栈是一个正在执行的工作表,那么消息队列就是一个代办的工作表,而事件循环就是先执行调用栈中的任务,然后再去执行消息队列中的任务,以此类推,这一过程,可以随时往消息队列里放置任务,这些任务会排队等待事件循环,然后在消息队列里按顺序压入到调用栈执行
  • 以上就是异步调用在JavaScript的实现过程以及它的基本原理,整个过程都是通过内部的消息队列和事件循环去实现的 image

这里我们需要注意的是JavaScript是单线程的而我们的浏览器不是单线程的,具体就是通过JavaScript调用的某些内部的api并不是单线程的,例如计时器,内部有一个单独的线程在倒数,在时间到了过后会将我们的回调函数放入消息队列,也就是说这样一件事情是有一个人单独去做的

同步模式的api是代码执行完才会继续往下走比如console.log; 异步模式的api就是下达这个任务开启任务的指令后就会继续执行,不会等待代码执行结束,如setTimeout

# 回调函数 (所有异步编程方案的根基)

image 由调用者定义,交给执行者执行的函数被称为回调函数,具体用法就是把函数作为参数传递

function foo (callback){
	setTimeout(function(){
		callback()
	})
}
foo(function(){
	console.log('这是回调函数')
	console.log('调用者定义这个函数,执行者执行这个函数')
	console.log('其实就是调用者告诉执行者异步任务结束时应该做什么')
})
1
2
3
4
5
6
7
8
9
10

除了这种传递参数的回调函数外还有几种常见的异步方式如事件机制和发订阅,个人认为这些都是基于回调函数的变体

# Promise

直接使用传统回调的方式去完成复杂的异步流程,无法避免大量的回调函数嵌套,这也就导致常说的回调地狱的问题,为了避免回调地狱的问题,commonjs社区率先提出来Promise规范,目的是为异步编程提供一个更合理更强大的统一解决方案,后来在ES2015当中被标准化,成为语言规范

所谓Promise就是一个异步对象,用来表示一个异步任务结束之后最终结束过后究竟是成功还是失败,就像是内部对外界做出来一个承诺(promise),一开始这个承诺是待定状态(Pending),最终有可能成功(fulfilled),也有可能失败(rejected) image 不管这个承诺是成功还是失败都会有相应的反应,也就是说承诺状态最终明确过后,都会有相对应的任务自动执行,而且这种承诺会有一个很明显的特点就是一但明确了结果过后就不可能发生改变了 image

// Promise 基本示例
const promise = new Promise(function(resolve,reject){
	// 这里用于兑现承诺
	// resolve('200');//承诺达成
	reject(new Error('Promise rejected'));//承诺失败
})
promise.then(function(value){
	console.log('resolved',value)
},function(error){
	console.log('rejected',error)
})
console.log('end')
// 需要注意的是,即便Promise当中没有任何的异步操作,
// then方法指定的回调函数仍然会在回调队列中排队,
// 也就是说这里需要等同步代码执行完了才回去执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Promise 使用案例

用Promise 封装ajax请求

// Promise 封装ajax
function ajax(url){
	return new Promise((resolve,reject)=>{
		const xhr = new XMLHttpRequest();
		xhr.open('GET',url);
		xhr.responseType = 'json'
		xhr.onload = function(){
			if(this.state === 200){
				resolve(this.response)
			}else{
				reject(new Error(this.statusText))
			}
		}
		xhr.send()
	})
}
ajax('apis/users.json').then((resolve)=>{
	console.log(resolve)
},(reject)=>{
	console.log(reject)
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 异步编程 单线程javascript异步方案

# javascript 采用单线程模式执行工作的原因?

与最早的设计初衷有关,JavaScript最早是运行在浏览器上的脚本语言,目的是实现页面上的动态交互,而实现页面交互的核心就是DOM操作,这也就决定了它必须实现单线程模型,否则会出现多线程同步的问题,假设DOM操作是多线程工作,这个修改了DOM,同时那个删除了DOM,这样浏览器就不能决定以哪个结果为准,所以为了避免线程同步的问题,JavaScript被设计成单线程模式工作

JavaScript单线程是指在js执行代码环境当中,负责执行代码的线程只有一个,这种模式的优点是更安全,更简单,缺点是遇到耗时的任务需要等待排队去实现,这会导致整个程序会被拖延出现假死的情况 image

# 同步模式

同步模式指我们代码中的任务必须依次执行,代码中的任务必须等待上一个任务执行完才能执行,程序的执行顺序和代码的编写顺序是完全一致的,这种方式会比较简单,在单线程情况下我们大多数任务都会以同步模式去执行,这里的同步指排队执行

js在执行过程中维护了一个正在执行的工作表,在这里我们会记录他当前做的事情,当工作表中的任务全部清空以后,这轮工作算是结束了

// 同步执行顺序 
//顺序0:首先会加载整体代码,在调用栈中压入一个匿名函数调用 
console.log('start');//顺序1
function bar(){
	console.log('bar');//顺序3
}
function foo(){
	console.log('foo');//顺序2
	bar()
}
foo()
console.log('end');//顺序4

// start
// foo
// bar
// end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这种排队执行的机制存在一个很严重的问题:如果其中某一行代码执行时间过长,后面的任务就会被延迟,那我们把这种延迟称之为阻塞,这种阻塞对于用户而言会有卡顿或卡死,所以需要异步模式来解决编程当中的耗时操作,如浏览器端的ajax或nodejs中的大文件读写

# 异步模式

异步模式不会等待这个任务的结束才开始执行下一个任务,对于耗时操作,它都是开启过后就立即执行下一个任务,耗时任务的后继逻辑都是通过回调函数的方式定义,在内部呢,耗时任务完成过后就会自动执行传入的回调函数

异步模式的重要性:没有异步模式,JavaScript无法处理大规模的耗时任务

相比于同步模式,异步的执行顺序是你不能确定的,跳跃的

// 异步执行顺序
//顺序0:首先会加载整体代码,在调用栈中压入一个匿名函数调用 
console.log('start');//顺序1
// 遇到异步调用,放在web apis中执行
setTimeout(function timer1 (){//注意倒计时器是单独工作的并不受我们的js线程影响
	console.log('timer1');//顺序4
},1800)
setTimeout(function timer1 (){
	console.log('timer2');//顺序3
	setTimeout(function timer1 (){
		console.log('timer3');//顺序5
	},1000)
	
},1000)
console.log('end');//顺序2
// start
// end
// timer2
// timer1
// timer3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  • 事件循环机制负责监听调用栈和消息队列,当调用栈中多有任务都结束后,事件循环机制会从消息队列取出第一个回调函数,然后压入到调用栈,此时的消息队列是空的,程序也就暂停了,等到计时器的倒计时结束后,先结束的timer2会被放在消息队列的第一位,time1放在消息队列的第二位,一但消息队列发生变化,时间循环机制就会监听到,然后把消息队列中的第一个time2压入调用栈,继续执行time2,此时对于调用栈相当于开启了新的执行,执行顺序是一致的,遇到异步调用就放在web api中执行,如此不断重复,直到调用栈和消息队列都没有需要执行的任务了,整体的代码就结束了
  • 如果说调用栈是一个正在执行的工作表,那么消息队列就是一个代办的工作表,而事件循环就是先执行调用栈中的任务,然后再去执行消息队列中的任务,以此类推,这一过程,可以随时往消息队列里放置任务,这些任务会排队等待事件循环,然后在消息队列里按顺序压入到调用栈执行
  • 以上就是异步调用在JavaScript的实现过程以及它的基本原理,整个过程都是通过内部的消息队列和事件循环去实现的 !image

这里我们需要注意的是JavaScript是单线程的而我们的浏览器不是单线程的,具体就是通过JavaScript调用的某些内部的api并不是单线程的,例如计时器,内部有一个单独的线程在倒数,在时间到了过后会将我们的回调函数放入消息队列,也就是说这样一件事情是有一个人单独去做的

同步模式的api是代码执行完才会继续往下走比如console.log; 异步模式的api就是下达这个任务开启任务的指令后就会继续执行,不会等待代码执行结束,如setTimeout

# 回调函数 (所有异步编程方案的根基)

image 由调用者定义,交给执行者执行的函数被称为回调函数,具体用法就是把函数作为参数传递

function foo (callback){
	setTimeout(function(){
		callback()
	})
}
foo(function(){
	console.log('这是回调函数')
	console.log('调用者定义这个函数,执行者执行这个函数')
	console.log('其实就是调用者告诉执行者异步任务结束时应该做什么')
})
1
2
3
4
5
6
7
8
9
10

除了这种传递参数的回调函数外还有几种常见的异步方式如事件机制和发订阅,个人认为这些都是基于回调函数的变体

# Promise

直接使用传统回调的方式去完成复杂的异步流程,无法避免大量的回调函数嵌套,这也就导致常说的回调地狱的问题,为了避免回调地狱的问题,commonjs社区率先提出来Promise规范,目的是为异步编程提供一个更合理更强大的统一解决方案,后来在ES2015当中被标准化,成为语言规范

所谓Promise就是一个异步对象,用来表示一个异步任务结束之后最终结束过后究竟是成功还是失败,就像是内部对外界做出来一个承诺(promise),一开始这个承诺是待定状态(Pending),最终有可能成功(fulfilled),也有可能失败(rejected) image 不管这个承诺是成功还是失败都会有相应的反应,也就是说承诺状态最终明确过后,都会有相对应的任务自动执行,而且这种承诺会有一个很明显的特点就是一但明确了结果过后就不可能发生改变了 image

// Promise 基本示例
const promise = new Promise(function(resolve,reject){
	// 这里用于兑现承诺
	// resolve('200');//承诺达成
	reject(new Error('Promise rejected'));//承诺失败
})
promise.then(function(value){
	console.log('resolved',value)
},function(error){
	console.log('rejected',error)
})
console.log('end')
// 需要注意的是,即便Promise当中没有任何的异步操作,
// then方法指定的回调函数仍然会在回调队列中排队,
// 也就是说这里需要等同步代码执行完了才回去执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Promise 使用案例

用Promise 封装ajax请求

// Promise 封装ajax
function ajax(url){
	return new Promise((resolve,reject)=>{
		const xhr = new XMLHttpRequest();
		xhr.open('GET',url);
		xhr.responseType = 'json'
		xhr.onload = function(){
			if(this.state === 200){
				resolve(this.response)
			}else{
				reject(new Error(this.statusText))
			}
		}
		xhr.send()
	})
}
ajax('apis/users.json').then((resolve)=>{
	console.log(resolve)
},(reject)=>{
	console.log(reject)
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21