超时功能怎么写？

Question

比如超过3分钟了就给个提示

Answer 1

Python
使用了signal模块来设置一个定时器（signal.alarm），并定义了一个超时处理函数（timeout_handler）。如果函数在规定时间内没有完成，定时器会触发超时处理函数，抛出一个TimeoutException异常。

import signal

class TimeoutException(Exception):
    pass

def timeout_handler(signum, frame):
    raise TimeoutException

def run_with_timeout(func, timeout):
    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(timeout)
    try:
        result = func()
    except TimeoutException:
        result = "Function timed out"
    finally:
        signal.alarm(0)
    return result

# Example usage
def example_function():
    import time
    time.sleep(300)  # Simulate a function that takes 5 minutes
    return "Function completed"

print(run_with_timeout(example_function, 180))  # Set timeout to 3 minutes

Javascript
使用了Promise和setTimeout来实现超时功能。创建一个定时器，如果函数在规定时间内没有完成，定时器会触发并拒绝Promise，返回一个超时错误。

function runWithTimeout(func, timeout) {
    return new Promise((resolve, reject) => {
        const timer = setTimeout(() => {
            reject(new Error("Function timed out"));
        }, timeout);

        func().then(result => {
            clearTimeout(timer);
            resolve(result);
        }).catch(err => {
            clearTimeout(timer);
            reject(err);
        });
    });
}

// Example usage
function exampleFunction() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve("Function completed");
        }, 300000);  // Simulate a function that takes 5 minutes
    });
}

runWithTimeout(exampleFunction, 180000)  // Set timeout to 3 minutes
    .then(result => console.log(result))
    .catch(err => console.error(err.message));

Go
使用了select语句和time.After来实现超时功能。启动一个goroutine来执行函数，并使用select语句等待函数完成或超时。如果函数在规定时间内没有完成，time.After会触发并返回一个超时错误。

package main

import (
    "errors"
    "fmt"
    "time"
)

func runWithTimeout(f func() (string, error), timeout time.Duration) (string, error) {
    resultChan := make(chan string)
    errorChan := make(chan error)

    go func() {
        result, err := f()
        if err != nil {
            errorChan <- err
        } else {
            resultChan <- result
        }
    }()

    select {
    case result := <-resultChan:
        return result, nil
    case err := <-errorChan:
        return "", err
    case <-time.After(timeout):
        return "", errors.New("Function timed out")
    }
}

// Example usage
func exampleFunction() (string, error) {
    time.Sleep(5 * time.Minute)  // Simulate a function that takes 5 minutes
    return "Function completed", nil
}

func main() {
    result, err := runWithTimeout(exampleFunction, 3*time.Minute)  // Set timeout to 3 minutes
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(result)
    }
}

5分钟（300秒）表示函数的实际执行时间，3分钟（180秒）表示允许函数执行的最大时间。如果函数在180秒内没有完成，就会触发超时处理逻辑。