异步函数外部堆栈上下文

有时代码想知道特定函数(或子函数)是否正在运行。例如，node.js 也有适用于异步内容的域(不确定这是否包括异步函数)。

一些简单的代码来解释我需要什么，如下所示：

inUpdate = true;
try {
doUpdate();
} finally {
inUpdate = false;
}

然后可以使用如下方式：

function modifyThings() {
if (inUpdate) throw new Error("Can't modify while updating");
}

随着async的出现，如果 doUpdate() 函数是异步的，则此代码会中断。当然，使用回调样式函数已经如此。

当然，可以修补doUpdate函数以维护每个await周围的变量，但即使您可以控制代码，这也很麻烦且容易出错，并且在尝试跟踪doUpdate内部的异步函数调用时会中断。

我尝试了猴子补丁Promise.prototype：

const origThen = Promise.prototype.then;
Promise.prototype.then = function(resolve, reject) {
const isInUpdate = inUpdate;
origThen.call(this, function myResolve(value) {
inUpdate = isInUpdate;
try {
return resolve(value);
} finally {
inUpdate = false;
}
}, reject);
}

不幸的是，这不起作用。我不确定为什么，但异步继续代码最终在resolve调用堆栈之外运行(可能使用微任务)。

请注意，仅仅做以下操作是不够的：

function runUpdate(doUpdate) {
inUpdate = true;
doUpdate.then(() => inUpdate = false).catch(() => inUpdate = false);
}

原因是：

runUpdate(longAsyncFunction);
console.log(inUpdate); // incorrectly returns true

有没有办法从异步函数外部跟踪某些内容，以便可以判断调用的函数或其任何后代调用是否正在运行？

我知道可以用生成器和yield模拟异步函数，在这种情况下，我们可以控制调用堆栈(因为我们可以调用gen.next())，但这是一个难题，异步函数的出现刚刚解决，所以我特别在寻找一种适用于本机(不是 Babel 生成的)异步函数的解决方案。

编辑：澄清问题：外部代码是否有办法知道异步函数的特定调用是否正在运行或是否挂起，假设此代码是异步函数的调用者。它是否正在运行将由最终由异步函数(堆栈中的某个位置)调用的函数决定。

编辑：澄清更多：预期的功能将与node.js中的域相同，但对于浏览器也是如此。域名已经可以使用承诺，因此async函数可能也可以工作(未经测试)。

这段代码允许我在一定程度上做我想做的事：

function installAsyncTrack() {
/* global Promise: true */
if (Promise.isAsyncTracker) throw new Error('Only one tracker can be installed');
const RootPromise = Promise.isAsyncTracker ? Promise.rootPromise : Promise;
let active = true;
const tracker = {
track(f, o, ...args) {
const prevObj = tracker.trackObj;
tracker.trackObj = o;
try {
return f.apply(this, args);
} finally {
tracker.trackObj = prevObj;
}
},
trackObj: undefined,
uninstall() {
active = false;
if (Promise === AsyncTrackPromise.prevPromise) return;
if (Promise !== AsyncTrackPromise) return;
Promise = AsyncTrackPromise.prevPromise;
}
};
AsyncTrackPromise.prototype = Object.create(Promise);
AsyncTrackPromise.rootPromise = RootPromise;
AsyncTrackPromise.prevPromise = Promise;
Promise = AsyncTrackPromise;
AsyncTrackPromise.resolve = value => {
return new AsyncTrackPromise(resolve => resolve(value));
};
AsyncTrackPromise.reject = val => {
return new AsyncTrackPromise((resolve, reject) => reject(value));
};
AsyncTrackPromise.all = iterable => {
const promises = Array.from(iterable);
if (!promises.length) return AsyncTrackPromise.resolve();
return new AsyncTrackPromise((resolve, reject) => {
let rejected = false;
let results = new Array(promises.length);
let done = 0;
const allPromises = promises.map(promise => {
if (promise && typeof promise.then === 'function') {
return promise;
}
return new AsyncTrackPromise.resolve(promise);
});
allPromises.forEach((promise, ix) => {
promise.then(value => {
if (rejected) return;
results[ix] = value;
done++;
if (done === results.length) {
resolve(results);
}
}, reason => {
if (rejected) return;
rejected = true;
reject(reason);
});
});
});
};
AsyncTrackPromise.race = iterable => {
const promises = Array.from(iterable);
if (!promises.length) return new AsyncTrackPromise(() => {});
return new AsyncTrackPromise((resolve, reject) => {
let resolved = false;
if (promises.some(promise => {
if (!promise || typeof promise.then !== 'function') {
resolve(promise);
return true;
}
})) return;
promises.forEach((promise, ix) => {
promise.then(value => {
if (resolved) return;
resolved = true;
resolve(value);
}, reason => {
if (resolved) return;
resolved = true;
reject(reason);
});
});
});
};
function AsyncTrackPromise(handler) {
const promise = new RootPromise(handler);
promise.trackObj = tracker.trackObj;
promise.origThen = promise.then;
promise.then = thenOverride;
promise.origCatch = promise.catch;
promise.catch = catchOverride;
if (promise.finally) {
promise.origFinally = promise.finally;
promise.finally = finallyOverride;
}
return promise;
}
AsyncTrackPromise.isAsyncTracker = true;
function thenOverride(resolve, reject) {
const trackObj = this.trackObj;
if (!active || trackObj === undefined) return this.origThen.apply(this, arguments);
return this.origThen.call(
this,
myResolver(trackObj, resolve),
reject && myResolver(trackObj, reject)
);
}
function catchOverride(reject) {
const trackObj = this.trackObj;
if (!active || trackObj === undefined) return this.origCatch.catch.apply(this, arguments);
return this.origCatch.call(
this,
myResolver(trackObj, reject)
);
}
function finallyOverride(callback) {
const trackObj = this.trackObj;
if (!active || trackObj === undefined) return this.origCatch.catch.apply(this, arguments);
return this.origCatch.call(
this,
myResolver(trackObj, reject)
);
}
return tracker;
function myResolver(trackObj, resolve) {
return function myResolve(val) {
if (trackObj === undefined) {
return resolve(val);
}
RootPromise.resolve().then(() => {
const prevObj = tracker.trackObj;
tracker.trackObj = trackObj;
RootPromise.resolve().then(() => {
tracker.trackObj = prevObj;
});
});
const prevObj = tracker.trackObj;
tracker.trackObj = trackObj;
try {
return resolve(val);
} finally {
tracker.trackObj = prevObj;
}
};
}
}
tracker = installAsyncTrack();
function track(func, value, ...args) {
return tracker.track(func, { value }, value, ...args);
}
function show(where, which) {
console.log('At call', where, 'from', which, 'the value is: ', tracker.trackObj && tracker.trackObj.value);
}
async function test(which, sub) {
show(1, which);
await delay(Math.random() * 100);
show(2, which);
if (sub === 'resolve') {
await Promise.resolve(test('sub'));
show(3, which);
}
if (sub === 'call') {
await test(which + ' sub');
show(3, which);
}
}
function delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
track(test, 'test1');
track(test, 'test2');
track(test, 'test3', 'resolve');
track(test, 'test4', 'call');

它用我自己的承诺取代了原生的承诺。此承诺存储承诺的当前上下文 (taskObj)。

当调用.then回调或其同类时，它会执行以下操作：

它创建了一个新的本机承诺，可以立即解决。这会向队列中添加一个新的微任务(根据规范，所以应该是可靠的)。
它调用原始解析或拒绝。至少在Chrome和Firefox中，这会在队列中生成另一个微任务，该队列将运行异步功能的下一部分。还不确定规范对此有何说明。它还会恢复调用周围的上下文，以便如果不await使用它，则不会在此处添加微任务。
第一个微任务被执行，这是我的第一个(本地)承诺被解决。此代码还原当前上下文 (taskObj)。它还创建了一个新的已解决的承诺，将另一个微任务排队
第二个微任务(如果有的话)被执行，在异步函数中运行JS，直到它到达下一个await或返回。
由第一个微任务排队的微任务被执行，这会将上下文恢复到承诺解决/拒绝之前的状态(应始终undefined，除非在tracker.track(...)调用之外设置)。

如果截获的承诺不是本机的(例如 bluebird)，它仍然有效，因为它在resolve(...)(和同类)调用期间恢复状态。

有一种情况我似乎找不到解决方案：

tracker.track(async () => {
console.log(tracker.taskObj); // 'test'
await (async () => {})(); //This breaks because the promise generated is native
console.log(tracker.taskObj); // undefined
}, 'test')

解决方法是将承诺包装在Promise.resolve()

：

tracker.track(async () => {
console.log(tracker.taskObj); // 'test'
await Promise.resolve((async () => {})());
console.log(tracker.taskObj); // undefined
}, 'test')

显然，需要对所有不同的环境进行大量测试，并且需要子调用的解决方法这一事实是痛苦的。此外，所有使用的承诺都需要包装在Promise.resolve()中或使用全局Promise。

[是否可以]判断调用的函数或其任何后代调用是否正在运行？

是的。答案总是否定的。因为一次只运行一段代码。Javascript是每个定义的单线程。

不要让它变得比它需要的更复杂。如果doUpdate返回一个承诺(比如当它是一个async function时)，只需等待：

inUpdate = true;
try {
await doUpdate();
//^^^^^
} finally {
inUpdate = false;
}

您还可以使用finally承诺方法：

var inUpdate = true;
doUpdate().finally(() => {
inUpdate = false;
});

这就像您的同步代码一样，在函数调用或其任何后代运行时具有inUpdate == true。当然，这只有在异步函数在完成其操作之前没有解决承诺时才有效。如果您觉得inUpdate标志应该只在doUpdate函数的某些特定部分设置，那么是的，函数需要维护标志本身 - 就像同步代码一样。

相关内容

最新更新

热门标签：