# 真正意义上的 异步IO 是说内核直接将数据拷贝至用户态的内存单元，再通知程序直接去读取数据。
 
# select / poll / epoll 都是同步IO的多路复用模式
 
 
1.同步和异步
 
# 同步和异步关注的是消息通信机制
 
# 所谓同步，就是在发出一个*调用*时，没得到结果之前，该*调用*就不返回。但是一旦调用返回就得到返回值了，*调用者*主动等待这个*调用*的结果
 
# 所谓异步，就是在发出一个*调用*时，这个*调用*就直接返回了，不管返回有没有结果。当一个异步过程调用发出后，*被调用者*通过状态，通知来通知*调用者*，或者通过回调函数处理这个调用
 
 
2.阻塞和非阻塞
 
# 阻塞和非阻塞关注的是程序在等待调用结果时的状态
 
# 阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才返回
 
# 非阻塞调用是指在不能立即得到结果之前，该调用不会阻塞当前线程
 
 
通俗例子一：
 
#老张爱喝茶

Promise 异步对象的学习记录
 
 // 定义一个Promise异步异步对象
        const p1 = new Promise((resolve,reject)=>{
            if(true){
                // 调用resolve函数，改变异步对象的状态为成功，且返回一个成功的数据出去
                resolve('我是成功状态！');

            }else{
                // 调用reject函数，改变异步对象的状态为失败，且返回一个失败的数据出去
                // 注意，异步对象的状态只能被改变一次，返回的数据就是这个异步对象的值
                reject('我是失败的状态！')
            }
        })


        // 也可以用语法糖---来简化一个异步对象
        const p2 = Promise.resolve(2);   // 这个也一个异步对象，且状态为成功，值为2
        const p3 = Promise.reject(3);   // 这个也是一个异步对象，且状态为失败，值3

        // 异步对象都可以通过实例对象的then()  方法来获取成功或者失败的数据
        p1.then((value)=>{
            // 第一个回调函数接收到的是成功状态的数据
            console.log('我是成功状态的数据；'+value);
        },(reason)=>{
            // 第二个回调函数接收的是失败状态的数据
            console.log('我是失败状态的数据；'+reason);
        })

        // 异步实例对象的catch()方法可以获取失败状态的数据
        p3.catch((reason)=>{
            console.log('我是失败状态的数据；'+reason);
        })


        // 1,promise对象的all() 方法，接收一个数组，数组元素为promise异步对象，
        //      返回值也是一个异步对象，状态由数组里面的异步对象决定，
        //          里面的异步对象都为成功状态，
        //              返回的就是一个成功状态的数据，该数据是一个数组，里面存放的就是多个异步对象成功状态返回过来的值
        //          里面的异步对象只要有一个为失败状态，
        //              返回的就是一个失败状态的数据，该数据就是那个返回失败状态的异步对象的数据值
        const pAll = Promise.all([p1,p2,p3])
        // 调用异步实例对象的then方法，获取他的值
        pAll.then(values=>{
            console.log('我是多个异步对象成功状态的成功数据的集合；'+values);
        },reason=>{
            console.log('我是多个异步对象中失败状态的数据；'+reason);
        })


        //2,异步对象的race()方法，接收的也是一个数组，里面元素也是异步对象，获取的是运行结束最快的那个异步对象的结果
        const pRace = Promise.race([p1,p2,p3])
        pRace.then(value=>{
            console.log('我是数组中运行最早结束的那个异步对象的成功状态的值；'+value);
        },reason=>{
            console.log('我是数组中运行最早结束的那个异步对象的失败状态的值；'+reason);

        })

        // js引擎是先执行同步代码，在去异步队列中执行异步代码
        //   队列分为微队列和宏队列，先执行完微队列在去执行宏队列

        // then()方法的返回的异步对象可以通过，return 返回成功的状态，改变成功的状态
        //                                  throw 抛出一个错误，将异步对象状态改为失败


        /*
        1，js中用来存储待执行回调函数的队列包含2个不同特定的列队
        2，宏列队；用来保存待执行的宏任务（回调），比如；定时器回调/DOM事件回调/ajax回调
        3，微列队：用来保存待执行的微任务（回调），比如；promise的回调/MutationObserver的回调
        4，js执行时会区别这2个队列
            （1）js引擎首先必须先执行所有的初始化同步任务代码
            （2）每次准备取出第一个宏任务执行前，都要将所有的微任务一个一个取出来执行
        
        */

        

同步和异步的区别
 
博主的学习记录
 
Docker汇总
Redis汇总
Vue汇总
MyBatis Plus汇总
微服务汇总
Java网络编程汇总
Java设计模式汇总
Java并发编程汇总
消息中间件汇总
 
原文地址
 
同步和异步，区别(已经不存在了)。
 
同步
 
所有的操作都做完，才返回给用户。这样用户在线等待的时间太长，给用户一种卡死了的感觉（就是系统迁移中，点击了迁移，界面就不动了，但是程序还在执行，卡死了的感觉）。这种情况下，用户不能关闭界面，如果关闭了，即迁移程序就中断了。
 
异步
 将用户请求放入消息队列，并反馈给用户，系统迁移程序已经启动，你可以关闭浏览器了。然后程序再慢慢地去写入数据库去。这就是异步。但是用户没有卡死的感觉，会告诉你，你的请求系统已经响应了。你可以关闭界面了。
 
同步，是所有的操作都做完，才返回给用户结果。即写完数据库之后，再响应用户，用户体验不好。
 异步，不用等所有操作都做完，就相应用户请求。即先响应用户请求，然后慢慢去写数据库，用户体验较好。
 
异步操作例子
 
为了避免短时间大量的数据库操作，就使用缓存机制，也就是消息队列。先将数据放入消息队列，然后再慢慢写入数据库。
 
引入消息队列机制，虽然可以保证用户请求的快速响应，但是并没有使得我数据迁移的时间变短（即80万条数据写入mysql需要1个小时，用了redis之后，还是需要1个小时，只是保证用户的请求的快速响应。用户输入完http url请求之后，就可以把浏览器关闭了，干别的去了。如果不用redis，浏览器不能关闭）。
 
同步就没有任何价值了吗？
 
银行的转账功能。
 

我们往往在项目中会遇到这样的业务需求，就是首先先进行一个ajax请求，然后再进行下一个ajax请求，而下一个请求需要使用上一个请求得到的数据，请求少了还好说，如果多了，就要一层一层的嵌套，就好像有点callback的写法了，那是相当恶心的，下面我就来讲一下如何使用ES6的新特性async await进行异步处理，使上述情况就好像写同步代码一样，首先我们先举个例子：
 先写上json文件:
 code.json:
 
{
    "code":0,
    "msg":"成功"
}
 
person.json:
 
{
    "code":0,
    "list":[
        {
            "id":1,
            "name":"唐僧"
        },
        {
            "id":2,
            "name":"孙悟空"
        },
        {
            "id":3,
            "name":"猪八戒"
        },
        {
            "id":4,
            "name":"沙僧"
        }
    ]
}
 
比如我们有两个请求，如下，这里用的axios：
 
 function getCode(){
      return axios.get('json/code.json');
  }
 function getlist(params){
      return axios.get('json/person.json',{params})
  }
 
我们第二个请求获取列表的时候需要使用第一个请求得到的code值，只有code值为0时，才能请求，而且当做参数传进去，那么我们看一下常规的做法吧
 
function getFinal(){
	  console.log("我是getFinal函数")
      getCode().then(function(res){
         if(res.data.code == 0){
               console.log(res.data.code);
                 var params = {
                      code:res.data.code
                  }
               getlist(params).then(function(res){
                    if(res.data.code == 0){
                         console.log(res.data.list);
                       }
                   })
                }
          })
      }
  getFinal();
 
看结果
 
 虽然结果出来了，可是这种写法真的挺难受的，下面来一个async await的写法
 
async function getResult(){
            console.log("我是getResult函数")
            let code = await getCode();
            console.log(code.data.code);
            if(code.data.code == 0){
                var params = {
                    code:code.data.code
                }
                let list = await getlist(params);
                console.log(list.data.list);
            }
        }
getResult();
 
下面看结果
 
 当然还剩最后一点，处理异常，可以加上try catch
 
async function getResult(){
            console.log("我是getResult函数")
            try{
				let code = await getCode();
	            console.log(code.data.code);
	            if(code.data.code == 0){
	                var params = {
	                    code:code.data.code
	                }
	                let list = await getlist(params);
	                console.log(list.data.list);
	            }
			}catch(err){
				console.log(err);
			}
        }
getResult();
 
个人认为做vue项目的时候，如果对于异常没有特殊处理，可以不加try catch，因为打印出来的错误跟vue自己报的错误是一样的，而且还是黑的字体，不如醒目的红色来的痛快啊！当然如果要对错误进行特殊处理，那么就加上吧
 
代码风格是不是简便了许多，而且异步代码变成了同步代码，下面我稍微讲一下后者写法的代码执行顺序
 
首先在 function 前面加 async 用来说明这个函数是一个异步函数，当然，async是要和await配合使用的，第一个请求
 
let code = await getCode();
 
await 意思是等一下，等着getCode（）这个函数执行完毕，得到值后再赋值给code，然后再用code的值进行下一步操作，就是这么简单！！！赶紧去改代码！！