超时是一种机制，使程序在指定时间内完成操作，以防止永久阻塞或请求超时。设置超时可以确保程序在预定时间内返回结果或执行下一步操作。过长的超时可能导致用户等待过久，而过短的超时可能导致程序未能完成必要的操作。

linux 设置超时时间

如不熟悉 linux ，慎重操作。(可忽略)

# 在Linux系统中，可以通过修改以下几个内核参数来设置TCP连接超时时间：

#1. tcp_syn_retries：指定连接建立超时时间，默认值为5，即最多等待5次SYN响应，每次等待时间为2秒。
#可以使用以下命令查看当前值：cat /proc/sys/net/ipv4/tcp_syn_retries
#可以使用以下命令修改当前值：echo 3 > /proc/sys/net/ipv4/tcp_syn_retries

#2. tcp_fin_timeout：指定连接关闭超时时间，默认值为60秒。
#可以使用以下命令查看当前值：cat /proc/sys/net/ipv4/tcp_fin_timeout
#可以使用以下命令修改当前值：echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

#3. tcp_keepalive_time：指定TCP连接的空闲超时时间，默认值为7200秒。
#可以使用以下命令查看当前值：cat /proc/sys/net/ipv4/tcp_keepalive_time
#可以使用以下命令修改当前值：echo 1800 > /proc/sys/net/ipv4/tcp_keepalive_time

# 修改重试n次 配置
vim /etc/sysctl.conf   # 编辑 
net.ipv4.tcp_syn_retries = 6 # (针对于ipv4) 次数是6 表示6*21 即 timeout是127秒；同理 =4 => timeout是31秒。
sysctl -p /etc/sysctl.conf  # 加载设置(-p后如果不跟文件名，默认从 /etc/sysctl.conf文件加载)

nginx 设置超时时间

如不熟悉 nginx ，慎重操作。(可忽略)

# nginx 超时时间设置
# 1.修改nginx配置文件
vim /etc/nginx/nginx.conf
# 2.修改超时时间 demo
client_header_timeout 3m;
client_body_timeout 3m;
send_timeout 3m;

# 在location中设置即可 demo：
proxy_connect_timeout 60; # 连接到主机超时时间，单位秒
proxy_read_timeout 300; # 从主机读取数据超时时间，单位秒

# 3.重启nginx
nginx -t
nginx -s reload

java 设置超时时间

springBoot 3.1.0 设置当前服务 http接口超时时间. ps:jdk21可以使用虚拟线程

@Slf4j
@Aspect
@Component
@Order(1)
public class TimeoutAspect {

    /**
     * 自行 初始化一个线程池
     */
    @Resource(name = "threadPoolTaskExecutor")
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    @Pointcut("execution(public * com.xxx.web.controller..*.*(..))")
    private void aspectController() {
    }

    @Around("aspectController()")
    public Object controllerLog(ProceedingJoinPoint pjp) throws Throwable {
        final Future<Object> future = threadPoolTaskExecutor.submit(() -> {
            try {
                return pjp.proceed();
            } catch (Throwable throwable) {
                throw new RuntimeException(throwable);
            }
        });
        //为了自测方便 设置超时时间 为 1秒
        try {
            return future.get(1, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            return Response.responeCodeMes(HttpStatus.REQUEST_TIMEOUT.value(), "service timeout");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

springBoot 3.1.0 使用 HttpClient 请求其他接口

import java.net.http.HttpClient;
HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10))

springBoot 3.1.0 使用 RestTemplate 请求其他接口

import org.springframework.web.client.RestTemplate;
@Bean(name = "restTemplate")
@ConditionalOnMissingBean(name = {"restTemplate"})
public RestTemplate restTemplate() {
    RestTemplate restTemplate = restTemplateBuilder
            //连接超时为10秒
            .setConnectTimeout(Duration.ofSeconds(10))
            //请求超时为10秒
            .setReadTimeout(Duration.ofSeconds(10))
            .build();
    return restTemplate;
}

java 中Grpc 设置超时时间。 （stub 为 proto文件生成的代理类）

# java 中Grpc 设置超时时间。 （stub 为 proto文件生成的代理类）
stub.withDeadlineAfter(10, TimeUnit.SECONDS)

golang 设置超时时间

echo 接口设置超时时间

# echo 接口设置超时时间
//timeout
    e.Use(mdl.TimeoutWithConfig(mdl.TimeoutConfig{
        Skipper:                    mdl.DefaultSkipper,
        ErrorMessage:               "{\"code\":408,\"msg\":\"service timeout\"}",
        OnTimeoutRouteErrorHandler: func(err error, c echo.Context) {},
        Timeout:                    10 * time.Second,
    }))

gin 接口设置超时时间

import (
    "github.com/gin-contrib/timeout"
    "github.com/gin-gonic/gin"
)
r := gin.New()
r.Use(Timeout())

func Timeout() gin.HandlerFunc {
    return timeout.New(
        //超时时间
        timeout.WithTimeout(common.TimeoutSecond),

        timeout.WithHandler(func(c *gin.Context) {
            c.Next()
        }),

        timeout.WithResponse(func(context *gin.Context) {
            context.JSON(http.StatusOK, map[string]interface{}{
                "code": http.StatusRequestTimeout,
                "msg":  "service timeout",
            })
        }),
    )
}

golang 中Grpc 设置超时时间。

    //超时设置
    ctx, cancel := context.WithTimeout(context.Background(),10 * time.Second)
    defer cancel()
    //执行
    res, err := *BaseServiceClient.Execute(ctx, req)
    if err != nil {
        var errRes fb_pb.ByteResult
        errRes.Code = -1
        errRes.Msg = err.Error()

        //获取错误状态
        errState, ok := status.FromError(err)
        //判断是否为调用超时
        if ok && errState.Code() == codes.DeadlineExceeded {
            errRes.Code = http.StatusRequestTimeout
            errRes.Msg = "System timeout"
        }

        return &errRes
    }

    return res