推迟代码执行的最佳方法是什么？

Question

我有许多相互调用的方法，每个方法都必须执行某些任务，其中一些是异步的，所有这些都在 DOM 上操作（因此任何时候只有一个线程必须访问 DOM）。

例如：

object A() {
    /*...A() code 1...*/
    var res = B();
    /*...A() code 2 that uses res...*/
}

object B() {
    /*...B code 1...*/
    var res1 = C();
    /*...B code 2 that uses res1...*/
    var res2 = C();
    /*...B code 3 that uses res2...*/
}

object C() {
    /*...C code 1...*/
    if (rnd.NextDouble() < 0.3) { // unpredictable condition
        startAsyncStuff();
        /*...C code 2 that uses async result above...*/
    }
    if (rnd.NextDouble() < 0.7) { // unpredictable condition
        startOtherAsyncStuff();
        /*...C code 3 that might use any/both async results above...*/
    }
}

现在假设我有一个方法想要以尽可能快的速度执行方法 A() 1000 倍（异步方法可以在单独的线程中运行，但是所有其他代码必须只能访问 DOM一次一个），因此理想情况下，当异步调用到达时，A()、B() 和 C() 的代码执行将暂停，以便可以再次调用 A()。

我可以想到两种方法来做到这一点。一种是使用yield，通过将所有方法更改为迭代器，我可以暂停和恢复执行：

struct DeferResult {
    public object Result;
    public bool Deferred;
}

IEnumerator<DeferResult> A() {
    /*...A() code 1...*/
    var dres = B();
    if (dres.Deferred) yield dres;
    /*...A() code 2...*/
}

IEnumerator<DeferResult> B() {
    /*...B code 1...*/
    var dres1 = C();
    if (dres1.Deferred) yield dres1;
    /*...B code 2...*/
    var dres2 = C();
    if (dres2.Deferred) yield dres2;
    /*...B code 3...*/
}

IEnumerator<DeferResult> C() {
    /*...C code 1...*/
    if (rnd.NextDouble() < 0.3) { // unpredictable condition
        startAsyncStuff();
        yield return new DeferResult { Deferred = true; }
        /*...C code 2 that uses async result above...*/
    }
    if (rnd.NextDouble() < 0.7) { // unpredictable condition
        startOtherAsyncStuff();
        yield return new DeferResult { Deferred = true; }
        /*...C code 3 that might use any/both async results above...*/
    }
    yield return new DeferResult { Result = someResult(); }
}

void Main() {
    var deferredMethods = new List<IEnumerator<DeferResult>>();
    for (int i = 0; i < 1000; i++) {
        var en = A().GetEnumerator();
        if (en.MoveNext())
            if (en.Current.Deferred)
                deferredMethods.Add(en);
    }
    // then use events from the async methods so when any is done continue
    //     running it's enumerator to execute the code until the next async
    //     operation, or until finished
    // once all 1000 iterations are complete call an AllDone() method.
}

• 此方法有相当多的来自迭代器的开销，并且代码密集一些，但是它全部运行在一个线程上，所以我不这样做不需要同步 DOM 访问。

• 另一种方法是使用线程（1000 个并发线程是一个坏主意，所以我会实现某种线程池），但这需要同步 DOM 访问，这是昂贵的。

在这些情况下我可以使用其他方法来推迟代码执行吗？推荐的方法是什么？

Answer 1

正如 Karl 所建议的，这需要多线程吗？ 我可能会选择多线程情况

1. 如果DOM 访问是随机的但不频繁，
2. A、B、C 中的所有其他代码在时间方面都很重要（与 DOM Access 代码相比）
3. A、B、C 中的所有其他代码都可以以线程安全的方式执行，不进行任何锁定等，即如果它们依赖于某些共享状态，那么您也可以同步访问该状态。

现在在这种情况下，我会考虑使用线程池来多次启动 A 并同步对 DOM 的访问。使用线程安全缓存可以降低 DOM 同步的成本 - 当然这取决于某种 DOM 访问。