Question

有时代码想知道特定功能（或子代）是否正在运行。例如，node.js有domains，它也适用于异步内容（不确定这是否包含异步函数）。

一些简单的代码来解释我需要的东西：

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中的domains相同，但也适用于浏览器。域已经与Promises一起使用，因此async函数可能也可以正常工作（未经过测试）。

Answer 1

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

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

Answer 2

不要让它变得比它需要的复杂。如果doUpdate返回一个承诺（就像它是一个async function），那就等一下：

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

您还可以使用finally Promise method：

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

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

Answer 3

此代码允许我在某种程度上做我想做的事情：

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');

它用我自己的Promise取代了原生的Promise。此承诺将当前上下文（taskObj）存储在promise上。

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

它会创建一个立即解析的新本机承诺。这会在队列中添加一个新的microtask（根据规范，因此应该是可靠的）。
它调用原始解析或拒绝。至少在Chrome和Firefox中，这会在队列上生成另一个微任务，该队列将运行async函数的下一部分。不知道规范对此有何评论。它还会恢复调用的上下文，这样如果它不是await使用它，那么就不会在这里添加微任务。
执行第一个微任务，这是我的第一个（本机）承诺被解决。此代码恢复当前上下文（taskObj）。它还创建了一个新的已解决的承诺，将另一个微任务排队
执行第二个微任务（如果有的话），在异步函数中运行JS，直到它到达下一个await或返回。
执行第一个微任务排队的微任务，将上下文恢复为Promise解决/拒绝之前的内容（应始终为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都需要包含在Promise.resolve()中或使用全局Promise。

异步函数外部堆栈上下文

3 个答案: