在特定时间停止承诺执行

Question

function sleep(t) {
    return new Promise((resolve, reject) =>{
        setTimeout(() => {
            console.log('timeout!')
            return resolve({isTimeout: true})
        }, t);
    });
}

function thirdPartyFunction(t) { // thirdPartyFunction can't be edited
    return new Promise((resolve, reject) =>{
        setTimeout(() => {
            console.log('thirdPartyFunction completed!')
            return resolve({success: true})
        }, t);
    });
}

function main() {
    return new Promise(async(resolve, reject) => {
        try {
            let thirdPartyFunctionExecutionTime =  Math.floor(Math.random() * 10) + 1;
            thirdPartyFunction(thirdPartyFunctionExecutionTime * 1000, false).then( (r) => {
                console.log('should not execute this if thirdPartyFunctionExecutionTime > timeout') // only goal
                // other code which is not useful after timeout
            });

            const timeout = 3;
            console.log(`thirdPartyFunctionExecutionTime: ${thirdPartyFunctionExecutionTime}, timeout - ${timeout}`)
            await sleep(timeout * 1000, true);
            throw 'stop main()'
            // return
        } catch (error) {
            console.log('in catch')
            return;
        }
    })
}


main()

超时是固定的。 在我的实际情况下，thirdPartyFunctionExecutionTime 可能非常大（有时），比如 30 秒。 我不想在超时后在后台运行某些东西。

thirdPartyFunction promise function 应该在超时时停止执行。

Answer 1

仅供参考，这里有一个通用的 function 添加超时和取消选项。 这可以与任何 promise 一起使用以为其添加超时。

如果由 promise 表示的底层异步操作是可取消的，那么您可以提供一个取消 function。如果异步操作先完成，这将自动为您清理计时器，因此它不会继续运行。

// the main purpose of this class is so that callers can test
// to see if the reject reason is a TimeoutError vs. some other type of error
class TimeoutError extends Error {
    constructor(...args) {
        super(...args);
    }

}

// add a timeout to any promise
function addTimeout(promise, t, timeoutMsg = "timeout") {
    let timer;
    const timerPromise = new Promise((resolve, reject) => {
        timer = setTimeout(() => {
            timer = null;
            // if the promise has a .cancel() method, then call it
            if (typeof promise.cancel === "function") {
                try {
                    promise.cancel();
                } catch(e) {
                    console.log(e);
                }
            }
            reject(new TimeoutError(timeoutMsg));
        }, t)
    });
    // make sure the timer doesn't keep running if the promise finished first
    promise.finally(() => {
        if (timer) {
            clearTimeout(timer);
        }
    })
    return Promise.race([promise, timerPromise]);
}

然后，您可以像这样在代码中使用它：

function main() {
    addTimeout(thirdPartyFunction(...), 3000).then(result => {
        // thirdPartyFunction succeeded and timeout was not hit
        // use the result here
    }).catch(err => {
        console.log(err);
        // an error occurred here
        if (err instanceof TimeoutError) {
            // timeout
        } else {
            // other error
        }
    })
}

如果您的异步操作能够在该操作超时时被取消，您可以像这样支持它：

function main() {
    let p = thirdPartyFunction(...);
    p.cancel = function () {
        // cancel the thirdPartyFunction here (depends uponn the specific operation)
    }
    addTimeout(p, 3000).then(result => {
        // thirdPartyFunction succeeded and timeout was not hit
        // use the result here
    }).catch(err => {
        console.log(err);
        // an error occurred here
        if (err instanceof TimeoutError) {
            // timeout
        } else {
            // other error
        }
    })
}