introduction
In complex distributed systems, timeout control is a key mechanism to ensure system stability and availability. This article will explore in-depth various solutions in Java that implement automatic cancellation of timeouts, from monolithic applications to distributed systems, from code level to middleware implementation.
1. Implementation based on Java native capabilities
1.1 CompleteFuture solution
public class TimeoutHandler {
private final ExecutorService executorService = ();
public <T> CompletableFuture<T> withTimeout(CompletableFuture<T> future, long timeout, TimeUnit unit) {
CompletableFuture<T> timeoutFuture = new CompletableFuture<>();
// Set timeout schedule ScheduledFuture<?> scheduledFuture = (() -> {
(
new TimeoutException("Operation timed out after " + timeout + " " + unit)
);
}, timeout, unit);
// Register the callback for the original task completion ((result, error) -> {
(false); // Cancel timeout schedule if (error != null) {
(error);
} else {
(result);
}
});
return timeoutFuture;
}
// Practical usage example public CompletableFuture<String> executeWithTimeout(String taskId) {
CompletableFuture<String> task = (() -> {
// Actual business logic return processTask(taskId);
});
return withTimeout(task, 5, )
.exceptionally(throwable -> {
// Timeout or exception handling logic handleTimeout(taskId);
throw new RuntimeException("Task execution failed", throwable);
});
}
}
1.2 Thread pool configuration optimization
@Configuration
public class ThreadPoolConfig {
@Bean
public ThreadPoolExecutor businessThreadPool() {
return new ThreadPoolExecutor(
10, // Number of core threads 20, // Maximum number of threads 60L, // Idle thread survival time ,
new LinkedBlockingQueue<>(500), // Work queue new ThreadFactoryBuilder()
.setNameFormat("business-pool-%d")
.setUncaughtExceptionHandler((t, e) -> ("Thread {} threw exception", (), e))
.build(),
new () // Reject policy );
}
}
2. Implementation plan in distributed scenarios
2.1 Distributed task timeout control based on Redis
@Service
public class DistributedTimeoutHandler {
@Autowired
private StringRedisTemplate redisTemplate;
public void startTask(String taskId, long timeout) {
// Set task status and timeout String taskKey = "task:" + taskId;
().set(taskKey, "RUNNING", timeout, );
// Register timeout listener (new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
((message, pattern) -> {
String expiredKey = new String(());
if ((taskKey)) {
handleTaskTimeout(taskId);
}
}, "__keyevent@*__:expired".getBytes());
return null;
}
});
}
private void handleTaskTimeout(String taskId) {
// Send a cancel signal String cancelSignalKey = "cancel:" + taskId;
().set(cancelSignalKey, "TIMEOUT", 60, );
// Notify related services notifyServices(taskId);
}
}
2.2 Delayed message implementation based on Apache RocketMQ
@Service
public class MQTimeoutHandler {
@Autowired
private RocketMQTemplate rocketMQTemplate;
public void scheduleTimeout(String taskId, long timeout) {
Message<?> message = (
new TimeoutMessage(taskId, ())
).build();
// Send delay message (
"TIMEOUT_TOPIC",
message,
timeout * 1000, // Timeout time is converted to milliseconds delayLevel(timeout) // Get the corresponding delay level );
}
@RocketMQMessageListener(
topic = "TIMEOUT_TOPIC",
consumerGroup = "timeout-consumer-group"
)
public class TimeoutMessageListener implements RocketMQListener<TimeoutMessage> {
@Override
public void onMessage(TimeoutMessage message) {
String taskId = ();
// Check whether the task is still executing if (isTaskStillRunning(taskId)) {
cancelTask(taskId);
}
}
}
}
3. Middleware integration solution
3.1 Spring Cloud Gateway timeout control
spring:
cloud:
gateway:
routes:
- id: timeout_route
uri: lb://service-name
predicates:
- Path=/api/**
filters:
- name: CircuitBreaker
args:
name: myCircuitBreaker
fallbackUri: forward:/fallback
metadata:
response-timeout: 5000
connect-timeout: 1000
3.2 Sentinel current limit downgrade configuration
@Configuration
public class SentinelConfig {
@PostConstruct
public void init() {
FlowRule rule = new FlowRule();
("serviceA");
(RuleConstant.FLOW_GRADE_QPS);
(10);
DegradeRule degradeRule = new DegradeRule();
("serviceA");
(RuleConstant.DEGRADE_GRADE_RT);
(200);
(10);
((rule));
((degradeRule));
}
}
4. Best Practice Recommendations
Implement multi-level timeout strategy and set different timeout times for different business scenarios
Use fuse mode to prevent cascading failures caused by timeout
Establish a complete monitoring and alarm mechanism to promptly detect timeout problems
Consider task graceful termination to ensure data consistency
Implement compensation mechanism to handle data cleaning and state recovery after timeout
5. Monitoring and operation and maintenance
@Aspect
@Component
public class TimeoutMonitorAspect {
private final MeterRegistry registry;
public TimeoutMonitorAspect(MeterRegistry registry) {
= registry;
}
@Around("@annotation(timeout)")
public Object monitorTimeout(ProceedingJoinPoint joinPoint, Timeout timeout) {
sample = (registry);
try {
return ();
} catch (TimeoutException e) {
("",
"class", ().getDeclaringTypeName(),
"method", ().getName()
).increment();
throw e;
} finally {
(("",
"class", ().getDeclaringTypeName(),
"method", ().getName()
));
}
}
}
Summarize
In an actual production environment, timeout control is not just a simple timeout cancellation, but also needs to consider multiple dimensions such as distributed consistency, resource release, monitoring and alarm. By rationally combining Java native capabilities, distributed coordination and middleware support, a robust timeout control mechanism can be built. It is important to choose the appropriate implementation plan based on the specific business scenarios and do a good job of fault tolerance and monitoring.
This is the end of this article about in-depth discussion on the implementation plan of Java timeout automatic cancellation. For more related contents of Java timeout automatic cancellation, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!