首先来说下同步异步与阻塞非阻塞的概念，同步异步与阻塞非阻塞并没有关系。同步异步主要是事情做完以后，如何进行处理、或者说关注的是一种消息通信机制。
同步的情况下，是由处理消息者自己去等待消息是否被触发；
而异步的情况下是由触发机制来通知处理消息者

举例：
所以同步异步可以说是对被请求方来说的，被请求者使用什么方式来告知处理结果

思考，思考。。。。。。。，好了，有答案了，当场告诉你 ——– 同步
这个问题需要一点时间，你先做点别的，等我想好了，去找你。 ——–异步

阻塞非阻塞，主要是对于请求者而言的

阻塞：发出请求等待结果返回，然后再处理后续的事情
非阻塞：发出请求不等待结果返回，可以接着做后续的事情

上代码：

/**当我们new Promise会得到一个Promise对象，该对象会有一个任务要完成，同时该对象会维护一个状态
PromiseStatus
    1:pending:正在处理
    2:resolved:已完成
    3:rejected:失败*/

let p1 = new Promise(function(resolve,reject){

    /**要做的事情通过一个函数来完成，该函数会接收两个值
    resolve
    reject
    这两个参数都是一个函数，当我们调用他们的时候，会改变当前任务的状态
    resolve() => resolved
    reject() => rejected */

    setTimeout(() => {
            var a = Math.random();
            if(a < 0.5){
                console.log(a,'p1失败')
                reject(a)
            }else{
                console.log(a,'p1成功')
                resolve(a)
            }
        },1000)
})

/**Promise对象还有一个then方法，当前任务成功的时候，会调用该方法，并执行该方法传入函数参数
then方法接收两个参数，它们都是函数
    第一个参数是当前状态为resolved时候执行
    第二个参数是当前状态为rejected时候执行*/

p1.then(a => {
      console.log('成功',a)
 },a => {
       console.log('失败',a)
 })
       
/**虽然then方法中的参数接收两个
    一个是成功的callback
    一个是失败的callback
    但是，在书写的时候，如果每一个then都传这两个callback的话，编写过程太麻烦，为了能够统一的处理失败Pormise对象又提供了一个新的方法：catch,catch方法也接收一个callback
    只要有一个Promise的状态变成了rejected，那么就会被catch方法捕获，执行catch的callback*/

.then((a) => {
    return new Promise((resolve,reject) => {
        setTimeout(() => {
                a *= a; 
                console.log(a,'p1成功')
                reject(a);
            },1000)
    })
}).then((a) => {
    console.log(a,'p1的then里成功')
}).catch((a) => {
    console.log(a,'失败捕获')
})

看打印出来的结果：
当p1中的随机数a < 0.5时，就直接进入catch里捕获到失败了，后面的then都不会执行

当p1中的随机数a > 0.5时，就进入到第一个then里，第一个then里又有一个promise对象，但是执行的是reject函数，所以就会直接到catch里捕获到失败

情形：在一个Promise任务中需要处理多个异步任务，这多个的异步任务是同时进行的，但是执行时间是不确定的，后续的任务需要这几个异步任务全部完成之后在执行，这时候就需要用到Promise里面提供的all方法来实现

var p1 = new Promise((resolve,reject) => {
    let a = 1;
    setTimeout(() => {
        a++;
        resolve(a);
    },Math.random() * 1000)
})

var p2 = new Promise((resolve,reject) => {
    let b = 2;
    setTimeout(() => {
        b++;
        resolve(b);
    },Math.random() * 1000)
})

/**把两个不同的异步任务分别包装在一个Promise对象里，然后调用Promise对象静态方法all，把上面多个不同异步Promise作为数组传递给all方法的参数，当多个异步任务的状态都变成resolve，那么all的状态才是resolved,但是只要有一个异步任务的状态变成了rejected,那么all的状态就会变成rejected*/

Promise.all([p1,p2]).then(([a,b]) => {
    console.log(a,b)
}).catch((err) => {
    console.log(err)
})

打印台：

over~