如何用同步的方式来实现异步编程？

已于 2022-02-15 22:18:09 修改
阅读量976 收藏 4
点赞数 1
分类专栏： 编程语言 文章标签： 异步回调 Promise Generator async/await Callback Hell
于 2022-02-14 23:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39805244/article/details/122934041
版权

 文章介绍了异步回调、Promise、Generator和async/await四种异步编程方案，通过分析它们的演进过程，我们可以看到Promise解决了异步回调的Callback Hell问题；Generator的出现让用同步的方式来实现异步编程成为了可能，async/await则是结合了Promise和Generator优势的语法糖。在开发中，我们应该根据实际情况，选择最合适的方案。

关键词：异步回调、Promise、Generator、async/await、Callback Hell、异步函数、回调函数、异步错误

一. 异步回调

  异步回调是最基础的异步编程方案，不足之处是：

  • 需要把回调作为参数传给异步函数。
  • 当串联执行多个异步操作时，会出现Callback Hell问题。

 示例一：连续发出两个请求，并且把第一个请求的结果作为第二个请求的参数。

function request(data,callback){
    setTimeout(()=>{
        callback(data * 2);
    },1000);
}

request(1,(data1)=>{
    console.log(data1);
    request(data1,(data2)=>{
        console.log(data2)
    });
})

 可以看出，如果串联执行的异步操作越多，将会导致回调函数层层嵌套。

二. Promise

 Promise解决Callback Hell的思路是：将异步操作和回调解耦。由Promise对象负责跟踪异步操作的完成状态和触发回调函数。

 示例：连续发出两个请求，并且把第一个请求的结果作为第二个请求的参数。

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

request(1).then(data1=>{
    console.log(data1)
    return request(data1);
}).then(data2=>{
    console.log(data2);
})

 下面通过实现一个简单的Promise类来了解其工作原理。

1. 创建Promise

 Promise对象如何跟踪异步操作的完成状态？

 Promise构造函数的入参是一个接受resolve和reject两个参数的处理器函数。在Promise对象被创建且返回新对象之前，处理器函数会被立刻执行，并传入resolve和reject参数。 处理器函数通常用来执行一些异步操作，并在操作完成后调用resolve/reject来变更Promise对象的状态。

const p4 = new Promise((resolve, reject) => {
    setTimeout(()=>{
        resolve('执行成功')
    },1000);
})

2. 状态变更

输入：

let p0 = new Promise((resolve, reject) => {})
console.log('p0', p0)

let p1 = new Promise((resolve, reject) => {
    resolve('成功')
})
console.log('p1', p1)

let p2 = new Promise((resolve, reject) => {
    reject('失败')
})
console.log('p2', p2)

let p3 = new Promise((resolve, reject) => {
    throw('报错')
})
console.log('p3', p3)

// 刚创建时，p4状态为pending，1000ms后变更为fulfilled。
const p4 = new Promise((resolve, reject) => {
    setTimeout(()=>{
        resolve('执行成功')
    },1000);
})

输出：

image-20220102102219777

结论：

  1. 刚创建的Promise对象处于pending状态。
  2. 当异步操作完成后，调用resolve/reject变更状态为fulfilled/rejected。
  3. 当处理器函数出错(同步错误)时，变更状态为rejected。

image-20220102193706740

实现：

class MyPromise {
    constructor(executor) {

        this.initValue();
        // 由于resolve/reject是外部函数executor调用的，所以必须将this硬绑定为当前MyPromise对象
        this.initBind();
        
        try {
            // 执行传进来的函数
            executor(this.resolve, this.reject);
        } catch (e) {
            // 捕捉到错误直接执行reject
            this.reject(e);
        }
    }

    initBind() {
        this.resolve = this.resolve.bind(this);
        this.reject = this.reject.bind(this);
    }

    initValue() {
        this.PromiseResult = null;
        this.PromiseState = 'pending';
    }

    resolve(value) {
        // 状态只能由pending转换为fulfilled/rejected
        if (this.PromiseState == 'pending'){
            this.PromiseState = 'fulfilled';
            this.PromiseResult = value;
        }
    }

    reject(reason) {
         // 状态只能由pending转换为fulfilled/rejected
        if (this.PromiseState == 'pending'){
            this.PromiseState = 'rejected';
            this.PromiseResult = reason;   
        }
    }
}

3. 触发回调

 通过Promise对象的then()来注册回调函数。当Promise对象从pending状态变更为fulfilled/rejected状态时，会自动触发回调函数。

输入/输出：

const p1 = new Promise((resolve, reject) => {
    resolve('执行成功');
}).then(res => console.log('resolve=',res), err => console.log('reject=',err))
// “立刻”输出 ”resolve=执行成功“

const p2 = new Promise((resolve, reject) => {
    reject('执行失败');
}).then(res => console.log('resolve=',res), err => console.log('reject=',err))
// “立刻”输出 ”reject=执行失败“

const p3 = new Promise((resolve, reject) => {
    reject('执行失败'); 
});
p3.then(res => console.log('resolve=',res), err => console.log('reject=',err));
// 输出 ”reject=执行失败“

结论：

  • then接收两个参数：成功回调和失败回调
  • 当Promise状态为fulfilled时执行成功回调，为rejected执行失败回调

实现：

  • 通过then注册回调时，如果Promise状态为fulfilled/rejected，则执行回调函数；
  • 如果Promise状态为pending，则先保存回调函数，等异步操作结束后再执行回调。
  • 捕获回调函数中的错误。
initValue() {
    ...
    // 保存回调函数。
    this.onFulfilledCallback;
    this.onRejectedCallback;
}

resolve(value) {
    ...
    // 状态变更为fulfilled，执行保存的成功回调
    if (this.onFulfilledCallback) {
        this.onFulfilledCallback(this.PromiseResult);
    }
}
reject(reason) {
    ...
    // 状态变更为rejected，执行保存的失败回调
     if (this.onRejectedCallback) {
         this.onRejectedCallback(this.PromiseResult);
     }
}

then(onFulfilled, onRejected) {
    // 参数校验，确保一定是函数
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
    if (this.PromiseState === 'fulfilled') {
        // 执行fulfilled回调
        onFulfilled(this.PromiseResult);
    } else if (this.PromiseState === 'rejected') {
        // 执行rejected回调
        onRejected(this.PromiseResult);
    }else if (this.PromiseState === 'pending') {
        // Promise为pending状态，暂时保存两个回调
       this.onFulfilledCallback = onFulfilled;
       this.onRejectedCallback = onRejected;
    }
}

4. 链式调用

 至此，Promise已经实现基本功能：跟踪异步操作完成状态和触发回调函数。但还没解决Callback Hell问题。而链式调用允许将进一步的操作与一个变为已完成状态的 Promise对象关联起来。

 实现方法就是在then()、catch()和finally()返回一个新的Promise对象。

输入/输出

const p1 = new Promise((resolve, reject) => {
    resolve(100);
}).then(res => 2 * res)
  .then(res => console.log(res))
// 链式调用 输出 200


const p2 = new Promise((resolve, reject) => {
    resolve(100);
}).then(res => new Promise((resolve, reject) => reject(3 * res)))
  .catch(res => console.log(res))
// 链式调用 输出300

// 捕获 回调函数中的错误
const p3 = new Promise((resolve, reject) => {
    resolve('执行成功');
}).then(res => {
    throw new Error("执行回调发生错误")
}).catch(err=>{
    console.log(err);
})

结论

  1. then方法本身会返回一个新Promise对象。
  2. 如果回调函数返回值是Promise对象，则新Promise对象状态由该Promise对象决定。
  3. 如果回调函数返回值不是Promise对象，则新Promise对象状态为成功。
  4. Promise会处理回调函数中的错误。

实现

 then(onFulfilled, onRejected) {
     ...
     var thenPromise = new MyPromise((resolve, reject) => {
         const resolvePromise = cb => {
             try {
                 const x = cb(this.PromiseResult)
                     if(x === thenPromise){
                         // 自己等待自己完成，循环等待：在then回调中返回了then的返回值。
                         reject(new TypeError('Chaining cycle detected for promise'));
                     }
                     if (x instanceof MyPromise) {
                         // 如果返回值是Promise对象，则新Promise状态由该Promise决定。
                         x.then(resolve, reject);
                    } else {
                        // 非Promise就直接成功
                        resolve(x);
                    }
                } catch (err) {
                    // 处理报错
                    reject(err);
                }
            }

            if (this.PromiseState === 'fulfilled') {
                // 如果当前为成功状态，执行第一个回调
                resolvePromise(onFulfilled);
            } else if (this.PromiseState === 'rejected') {
                // 如果当前为失败状态，执行第二个回调
                resolvePromise(onRejected);
            } else if (this.PromiseState === 'pending') {
                // 如果状态为待定状态，暂时保存两个回调
                this.onFulfilledCallback = resolvePromise(onFulfilled);
                this.onRejectedCallback = resolvePromise(onRejected);
            }
        })

        // 返回这个包装的Promise
        return thenPromise;

    }

5. 调用时序

 输入/输出

setTimeout(()=>{console.log(0)},0);
const p = new Promise((resolve, reject) => {
    console.log(1);
    resolve()
}).then(() => console.log(2))

console.log(3)

// 输出顺序是 1 3 2 0

结论

  1. 即使Promise的状态被立刻更新为fulfilled，回调函数也不会被立刻执行。
  2. 回调函数是在事件循环的微任务中执行的。
  3. 因为回调本来就是异步的，放在微任务执行可以让后面的同步代码尽快被执行。

实现

const resolvePromise = cb => {
    setTimeout(() => {
       // 执行回调...
    })
}

6. 应用场景

1. 封装异步回调

 异步回调存在 Callback Hell和缺少错误处理等问题，使用Promise对已存在的异步回调进行封装。

// 下面是一个典型的超时回调，由于timeoutCallback是异步执行的，所以无法捕获回调中的错误。
try{
    setTimeout(()=>timeoutCallback("3 seconds passed"), 3000);
}catch(err){
    // 这里是无法捕获到 timeoutCallback错误的。
    console.log(err);
}

// Promise可以将异步操作和回调分开,当异步操作完成后触发回调时，会自动在回调函数加上try catch。
const wait = ms => new Promise(
    resolve => setTimeout(resolve, ms)
);
wait(3000).then(
    () => timeoutCallback("3 seconds passed")
).catch(err=>{
    console.log(err)
});

2. 执行多个异步操作

 示例1：并行执行多个异步任务，并等待结果

// 并行多个异步操作，然后等所有操作完成后进入下一步操作
Promise.all([promise1, promise2, promise3])
.then(([result1, result2, result3]) => { 
    // next step 
});
.catch(err){
    // 当任意一个操作reject时，进入catch，并返回对应reject信息。
}

 示例2：串联执行多个异步任务

// 按顺序执行多个异步操作(链式调用)
[promise1, promise2, promise3].reduce((pre, cur) => pre.then(()=>{return cur}), Promise.resolve())
.then(result3 => {
    /* use result3 */ 
}).catch(err=>{
    // 当任意一个操作reject时，进入catch，并返回对应reject信息。
});
// 在es2017中，也可以使用async/await对上面代码进行优化
let result;
try{
    for (const pro of [promise1, promise1, promise1]) {
        result = await pro(result);
    }
}catch(err){
    result = err;
}

 示例3：控制异步任务的最大并发数。

class limitCountTaskExec{
    constructor(maxCount){
        this.maxCount = maxCount;
        this.count = 0;  
        this.paddingTasks = [];
    }
    run(task){
        if(task instanceof Array){
            task.forEach(t=>{
                this.run(t)
            });
        }else{
            if(this.count != this.maxCount){
                this.count++;
                task().finally(()=>{
                    this.count--;
                    this.paddingTasks.length!=0 && this.run(this.paddingTasks.shift());
                })
            }else{
                this.paddingTasks.push(task);
            }
        }
        
    }
}

function request(data) {
  return new Promise((resolve,reject) => {
    setTimeout(() => {
      reject('请求失败')
    }, 1000)
  })
}

let taskExec = new limitCountTaskExec(3);
for(let i=0; i<10; ++i){
    taskExec.run(request);
}

3. 转移内部状态控制权

 将 Promise 的 Resolve、Reject 的句柄传递到迭代函数中，来控制 Promise 的内部状态转化

 示例1：请求失败时，最多重试3次。

function request(data) {
  return new Promise((resolve,reject) => {
    setTimeout(() => {
      reject('请求失败')
    }, 1000)
  })
}
// Promise实现
function getLimiteTimeRequestPromise(ajaxRequest){
    return function(){
        let args = arguments;
        let self = this;
        return new Promise((resolve,reject)=>{
            let count = 3;
            function run(){
                ajaxRequest.apply(self,args).then(data=>{
                    resolve(data);
                }).catch(err=>{
                    console.log('请求失败，重试')
                    --count==0 ? reject(err) : run();
                });
            }
            run();
        });
    }
}
// async实现
function getLimiteTimeRequestAsync(ajaxRequest){
    return async function(){
        let args = arguments;
        let self = this;
        let count = 3;
        while(count--){
            try{
                let data = await ajaxRequest.apply(self,args);
                return Promise.resolve(data);
            }catch(err){
                console.log('请求失败，重试')
                if(0 == count){
                    return Promise.reject(err);
                }
            }
        }
    }
}

let limitRequest = getLimiteTimeRequestPromise(request);
limitRequest().then(data=>{
    console.log(data)
}).catch(err=>{
    console.log(err)
})

7. 不足

 Promise解决了异步回调的Callback Hell问题。但不足之处是：

  • 代码不够简洁：需要通过then()注册回调函数。
  • 链式调用时无法断点。

三. Generator

 Generator可以控制函数的执行流程(暂停/执行)，让用同步的方式来实现异步编程成为了可能。

1. 控制函数执行流程

 Generator对象是由generator function返回的一个可迭代对象。通过调用Generator对象的next()方法可以让generator function内部执行到下一个标有yield关键字的位置。

 通常一个函数被调用时，直到函数执行完毕后才把控制权转移给调用处代码。而Generator对象可以控制函数内部的执行流程(暂停和继续执行)，例如：

function* gen(data){
    let data1 = yield data+1; // 第一个断点
    let data2 = yield data1+1;  // 第二个断点
    return data2+1;
}

let g = gen(1);  // generator函数返回Generator对象
let data1 = g.next();  // 执行到gen函数第一个yield位置处：{value: 2, done: false}
let data2 = g.next(data1.value);  // 执行到gen函数第二个yield位置处：{value: 3, done: false}
g.next(data2.value);  // gen函数最后返回：{value: 4, done: true}

注：

  • next()的入参 会传给上一个yield语句=号左边的变量。
  • next()返回的对象包含value 和 done两个属性。value是当前yield表达式的值，done表示genenrator function是否执行完毕。

2. 异步编程转同步

 Generator实现用同步的方式来实现异步编程的思路是：控制函数在有异步操作的地方暂停，等待其完成并返回结果后，再继续执行。

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

function* gen(data){
    let data1 = yield request(data);
    let data2 = yield request(data1);
    return request(data2);
}

let g = gen(1);
g.next().value.then(data1=>{
    console.log(data1);
    g.next(data1).value.then(data2=>{
        console.log(data2);
    });
});

 上面的代码需要手动调用next()来执行下一个异步操作，下面我们通过一个高阶函数进行封装简化:

  • 入参是generator function。返回值是一个返回Promise对象的函数。
  • 函数内部自动执行next()，并判断是否执行完毕。
function generator2asyncFn(gen){
    return function(){
        // 可通过asyncFn给gen传参
        let g = gen.apply(this,arguments);
        return new Promise((resolve,reject)=>{
            function go(data){
                let nextResult;
                try{
                    nextResult = g.next(data);
                }catch(err){
                    return reject(err);
                }
                let {value,done} = nextResult;
                 if(done){
                     return resolve(value); 
                 }else{
                     Promise.resolve(value).then(data=>{
                         return go(data);
                     }).catch(err=>{
                         return reject(err);
                     });
                 }
            }
            go();	
        });
    }
}

 通过generator2asyncFn高阶函数生成的asyncFn函数，可以自动执行next()并判断是否执行完毕，让generator function变得更加实用了。

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

function* gen(data){
    let data1 = yield request(data);
    let data2 = yield request(data1);
    return data2;
}

let asyncFn = generator2asyncFn(gen);
asyncFn().then(res => console.log(res))

四. async/await

 async/await其实是一个异步编程的语法糖，上面我们结合Promise和Generator实现的generator2asyncFn函数生成了一个async函数。

示例代码：

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

async function requests(data){
    let data1 = await request(data);
    let data2 = await request(data1);
    return data2;
}

注：

  • await 操作符用于等待一个Promise 对象：返回Promise对象resolve值，非Promise对象返回表达式的值(区别于yield)。
  • await等待的Promise对象reject时，会抛出错误，可以被await外部catch。
  • async函数返回一个Promise对象。

五. 总结

Promise VS 异步回调

1. Callback Hell

 Promise的链式调用解决了Callback Hell问题。

// 异步回调 实现串联执行多个异步操作
function request(data,callback){
    setTimeout(()=>{
        callback(data * 2);
    },1000);
}

request(1,(data1)=>{
    console.log(data1);
    request(data1,(data2)=>{
        console.log(data2)
    });
})
// Promise 实现串联执行多个异步操作
request(1).then(data1=>{
    console.log(data1)
    return request(data1);
}).then(data2=>{
    console.log(data2);
})

2. 错误处理

 Promise对象会自动捕获处理器函数(Promise构造函数的入参)和回调函数中的同步错误。

 注：什么是同步错误和异步错误？

// try/catch无法捕获异步执行的函数中的错误。
try{
    setTimeout(()=>timeoutCallback("3 seconds passed"), 3000);
}catch(err){
    // 这里是无法捕获到 timeoutCallback错误的。
    console.log(err);
}

// 与之相反的就是同步错误
try{
    throw new Error('发生错误');
} catch(err){
    console.log(err); // 打印 Error: 发生错误
}

 Promise在执行处理器函数和回调函数时都做了错误处理(详见上文)。

// 捕获处理器函数中的错误
const p1 = new Promise((resolve, reject) => {
    throw new Error('处理器函数发生错误');
}).then(res => console.log('resolve=',res), err => console.log('reject=',err))
// 打印：reject= Error: 处理器函数发生错误

// 捕获回调函数中的错误
const p2 = new Promise((resolve, reject) => {
    resolve('执行成功');
}).then(res => {
    throw new Error('回调函数发生错误');
}).catch(err=>{
    console.log('catch=',err);
})
// 打印：catch= Error: 回调函数发生错误

Promise VS async/await

1. 异步转同步

  • async/await代码更简洁：同步等待异步操作返回结果，不需要Promise.then()注册回调。

 例如，连续发出两个请求，并且把第一个请求的结果作为第二个请求的参数。

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

request(1).then(data1=>{
    console.log(data1)
    return request(data1);
}).then(data2=>{
    console.log(data2);
})

async function requests(data){
    let data1 = await request(data);
    let data2 = await request(data1);
    return data2;
}

2. 异步流程控制

 async/await解决了Promsie链式调用无法断点的问题。

 示例：连续发出两个请求，根据第一个请求的结果来确定是否发第二个请求。

function request(data) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(data * 2)
    }, 1000)
  })
}

async function requests(data){
    let data1 = await request(data);
    if(0 == data1){
        return 0;
    }
    let data2 = await request(data1);
    return data2;
}

参考文献

mdn_promise

mdn_async

Promise 向左，Async/Await 向右？

看了就会，手写Promise原理，最通俗易懂的版本

使用promise封装worker

程序员ys567
关注
专栏目录
JS异步编程同步化
ice_teas的博客
01-14 767
问题背景 同步是指一件事一件事的执行，只有前一个任务执行完毕，才能执行后一个任务。 异步(async)是相对于同步(sync)而言的，由于JavaScript是单线程运行的，为了避免阻塞带来的糟糕体验，异步操作成了必不可少的一种编程模式，js实现异步操作的方式有很多，包括回调函数、时间监听、发布/订阅模式、定时函数，包括ES6及以后的promise，Generator函数及各种语法糖。 这里...
协程Coroutine——用同步的方式编写异步的逻辑
果冻的专栏
10-01 6803
协程Coroutine——用同步的方式编写异步的逻辑摘要：Lua中的协程是用户级线程，任何时候只有一个协程在真正运行，程序员能够控制协程的切换和运行，可以用同步的方式编写异步的逻辑。 进程、线程、协程在操作系统中，进程拥有自己独立的内存空间，多个进程同时运行不会相互干扰，但是进程之间的通信比较麻烦；线程拥有独立的栈但共享内存，因此数据共享比较容易，但是多线程中需要利用加锁来进行访问控制：这是个非常头
java asynccallback_5种必会的Java异步调用转同步的方法你会几种
weixin_39696518的博客
02-16 683
Sunny先来说一下对异步和同步的理解：同步调用：调用方在调用过程中，持续等待返回结果。异步调用：调用方在调用过程中，不直接等待返回结果，而是执行其他任务，结果返回形式通常为回调函数。其实，两者的区别还是很明显的，这里也不再细说，我们主要来说一下Java如何将异步调用转为同步。换句话说，就是需要在异步调用过程中，持续阻塞至获得调用结果。不卖关子，先列出五种方法，然后一一举例说明：使用wait和no...
Java中的同步与异步编程
最新发布
聚娃科技开发者博客
09-13 682
大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！同步和异步是编程中的两个基本概念，理解并掌握它们对编写高效的并发应用程序非常重要。同步编程是一种在同一时间只能执行一个任务的编程方式。异步编程的一个常见应用是使用回调函数处理异步任务的结果。方法用于在另一个线程中异步执行任务，而主线程则继续执行自己的任务，不会被阻塞。异步编程的另一个重要应用是并行处理多个任务。方法注册一个回调函数，当结果计算完成后，该回调函数会被调用。在这个示例中，两个异步任务并行执行，
async await使用同步方式写异步代码
浮游的博客
09-05 616
自从网页中引入了 JavaScript，操作 DOM 树中任意一个节点就变得非常容易了，例如隐藏 / 显示节点、改变颜色、获得或改变文本内容、为元素添加事件响应函数等等。不过在 XMLHttpRequest 出现之前，如果服务器数据有更新，依然需要重新刷新整个页面。
同步转为异步设计
u012307248的专栏
11-11 637
同步模式：服务器在发送请求时，阻塞等待请求的响应；        优点：实现简单，同步接收数据，方便做各种统计和服务器的切换。缺点：服务不平稳，容易受到冲击，造成雪崩；        异步模式：服务器发送请求后，马上处理别的消息；        优点：服务吞吐量大，不容易受到冲击，可以采用并发策略，提高响应时间；缺点：实现困难，需要各种中间状态的存储。如果遇到多个服务交互的情况，
rust怎么实现异步编程？
05-20
例如，下面是一个使用 `async/await` 语法和 `tokio` 运行时库实现异步编程的示例： ```rust use tokio::fs::File; use tokio::io::AsyncReadExt; async fn read_file() -> Result<(), std::io::Error> { let mut...
javascript使用Promise对象实现异步编程
10-22
JavaScript异步编程是前端开发中的一个重要话题，随着JavaScript语言的发展和Web应用的复杂度增加，异步编程逐渐变得不可或缺。在ES6（ECMAScript 2015）之前，异步编程通常依赖于回调函数（callback），但这种方式...
如何在Python中实现异步编程？
读芯术的博客
10-24 1026
全文共2036字，预计学习时长6分钟 图源：unsplash 异步编程是并行编程的一种方式。单个工作单元独立于主应用程序线程运行，并通知调用线程其完成、失败情况或进度。下面这张图理解起来会更直观一些： 同步vs异步 同步编程很普遍。如图，请求1被发出后等待响应1；一旦得到响应1就发出请求2，然后等待它的响应。在上面的代码中，向函数传递参数“a”后等待函数返回更改后的值，然后再次调用以更改数字，最后再次得到响应，这就是同步编程。 而对于异步编程来说，请求1被发出后...
异步编程的方式有哪几种？
Windfall_rjh的博客
09-24 1556
目录 前言 一、JS任务的执行模式 二、异步编程的六种方式 1.回调函数方式 2.Promise对象 3.事件监听 4.发布/订阅 5.async/await 函数的实现 6.生成器函数 Generator/ yield 三、总结 四、参考文献 前言 众所周知，Javascript语言的执行环境是"单线程"（single thread），这就导致JS一次只能运行一个任务，如果有多个任务，就必须排队，前面一个任务完成，再执行后面一个任务，以此类推。 提示：以下是本篇文章正文内容，下
同步转异步机制
未知2018
12-06 1032
现状：华鸿平时每天有3W笔左右请求量，月初高峰期6W笔/天。        通信：Socket长链接        瓶颈：由于华鸿和移动网络问题原因，使华鸿内部处理慢，不能及时返回处理结果，导致我方有大量超时订单。同时在超时等待期间，线程资源不能及时释放，后续交易无法进来。          解决方案：同步转异步        即，1.网关收到交易请求之后，做必要的业务处理并组织请求报文
异步、同步以及异步的各种解决方法
weixin_43473114的博客
01-08 1722
1. 异步和同步 js是单线程语言，遇到等待（网络请求、定时任务）不能卡住，所以需要异步。 同步和异步的区别：同步同时只能做一件事情，会阻塞代码的执行，异步可以同时进行多个操作，不会阻塞代码的执行 异步通过callback形式调用。 //异步 通过callback形式调用 异步不会阻塞代码执行 console.log(100) setTimeout(() => { ale...
JS 同步转异步之Promise
heima201907的博客
05-27 1257
同步方法在promise示例中变成异步执行： [url=][/url] console.log(1);let p =newPromise(resolve => {console.log(2);resolve();console.log(3);});console.log(4);p.then(() => {console.log(5);});console.log(6);[url=][/url] 输出： 由此，利用Promise实现同步转异步函数： [url=]...
回调和协程：利用同步思路处理异步响应的本质
heisehuanyin的博客
09-24 918
编程领域的同步和异步 同步：指一个执行序1在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个执行序将会一直等待下去，直到收到返回信息才继续执行下去； 异步：指执行序不需要一直等下去，而是继续执行下面的操作，不管其他执行序的状态。当有消息返回时系统会通知指定执行序进行处理。这样在等待操作完成的过渡事件，系统可以有效利用cpu的资源。 从以上定义可以看出同步和异步之间的区别在于主动权...
C#中的同步编程和异步编程
MechMaster
07-28 391
【代码】C#中的同步编程和异步编程。
java的同步方法异步处理
riapgypm的专栏
12-29 5686
有时需要处理一个大任务，这个大任务处理完可能需要80秒，如果按照正常来访问就会出现超时，这时就会想着把这个大任务拆分，比如可以分成两个（根据任务性质来拆分）可以并行处理的子任务，第一个子任务用时30秒，第二个子任务用时30秒，再花20秒来整合结果，这样只用了50秒就完成了，就不会超时了。 下面是这个思路的一个简单实现： 任务一代码：import java.util.concurrent.Cal
如何将同步调用转换成异步调用
runyon的博客
10-10 3720
同步/非同步本来是IO方面的概念，不过我们可以把函数乃至各种RPC理解成一种IO设备，这样就可以把这两个词扩展到函数调用领域了。同步的函数调用指的是当函数调用返回的时候，需要函数干的事已经完成。而异步调用则没有这个保证，工作可能在函数返回前完成，也可能在之后某个时刻。     同步/异步很容易跟阻塞/非阻塞混淆起来。严格说起来它们是有区别的：阻塞的调用指的是当前提满足的时候干活，不满足的时候等到
异步编程--介绍同步和异步
jiaojsun的博客
09-26 718
1.异步编程 js是单线程的，所谓线程类似于游戏中的任务线。 一个主要的任务流程，处理我们的js程序，把一些耗时的事情通过新开线程的方式来实现，这就叫做异步编程。 常用的异步方式有     - setTimeout     - setInterval     - ajax 2.同步和异步解释 首先搭建一个简易的服务器 app.js代码如下，3s后返回请求。 const express...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值