重试模式基础
学习重试模式的基础知识，自动重新尝试失败的操作，提高系统健壮性。
重试模式基础 是 CoddyKit 上的免费 Microservices Communication Patterns (Saga, Circuit Breaker) 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Microservices Communication Patterns (Saga, Circuit Breaker) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Microservices Communication Patterns (Saga, Circuit Breaker) 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Facing Temporary Glitches?
Imagine you're trying to send a message, but your internet connection blips for a second. What do you do?
You probably try again! This simple human behavior is the core idea behind the Retry Pattern in software.
What is the Retry Pattern?
The Retry Pattern is a fundamental resilience technique. It involves automatically re-attempting an operation that has failed.
It's used when we expect the failure to be transient, meaning temporary and likely to resolve itself shortly, such as a brief network outage or a temporary database lock.
Why Use Retries?
In distributed systems, services often depend on each other. Failures can occur for many reasons:
- Network issues: A brief disconnection or high latency.
- Resource contention: A database or service is temporarily overloaded.
- Service restarts: A dependent service is briefly unavailable during an update.
Retries help your application recover gracefully from these hiccups without crashing or requiring manual intervention.
The Basic Retry Loop
At its simplest, the retry pattern works like this:
- Attempt an operation.
- If it fails, check if it's a retriable error.
- If retriable, increment a counter and try again.
- Stop after a certain number of attempts or if it succeeds.
Let's see a basic example without any delays yet.
Code: Simple Retry Logic
This code simulates an operation that fails twice before succeeding. Notice how the while loop keeps trying until it works or runs out of attempts.
public class Main {
public static void main(String[] args) {
boolean success = false;
int maxAttempts = 3;
int currentAttempt = 0;
while (!success && currentAttempt < maxAttempts) {
currentAttempt++;
System.out.println("Attempt " + currentAttempt + ": Trying to connect...");
// Simulate failure for first two attempts
if (currentAttempt < 3) {
System.out.println("Connection failed!");
} else {
System.out.println("Connection successful!");
success = true;
}
}
if (!success) {
System.out.println("Failed after " + maxAttempts + " attempts.");
}
}
}Adding a Delay: Fixed Retry
Simply retrying immediately might overwhelm a struggling service or fail again if the issue needs time to resolve. That's why we add delays.
A Fixed Delay Retry waits the same amount of time between each failed attempt. This gives the system a chance to recover.
Code: Fixed Delay Retry
Here, we've added a 1-second delay (1000ms) using Thread.sleep() after each failed attempt. This is a common practice to give the system some breathing room.
public class Main {
public static void main(String[] args) {
boolean success = false;
int maxAttempts = 3;
int currentAttempt = 0;
long delayMillis = 1000; // 1 second delay
while (!success && currentAttempt < maxAttempts) {
currentAttempt++;
System.out.println("Attempt " + currentAttempt + ": Trying to connect...");
// Simulate failure for first two attempts
if (currentAttempt < 3) {
System.out.println("Connection failed!");
try {
Thread.sleep(delayMillis); // Wait before retrying
System.out.println("Waiting " + delayMillis + "ms...");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
} else {
System.out.println("Connection successful!");
success = true;
}
}
if (!success) {
System.out.println("Failed after " + maxAttempts + " attempts.");
}
}
}Smarter Waits: Exponential Backoff
While fixed delays work, sometimes it's better to increase the wait time with each successive retry. This is called Exponential Backoff.
For example, you might wait 1s, then 2s, then 4s, then 8s. This reduces the load on a struggling service and gives it more time to recover.
When to Use the Retry Pattern
Retries are most effective for:
- Transient network errors: Brief disconnections, timeouts.
- Temporary resource unavailability: A database connection pool is momentarily exhausted.
- Optimistic concurrency conflicts: When multiple users try to update the same record at once.
- Brief service restarts: A microservice is being redeployed.
When NOT to Use Retries
Retries are not a silver bullet. Avoid using them for:
- Non-transient errors: Errors caused by invalid input, authorization failures, or missing resources that won't resolve on their own.
- Non-idempotent operations: If repeating an operation has unintended side effects (e.g., charging a customer twice). Idempotency means an operation can be performed multiple times without changing the result beyond the initial application.
- Long-lasting failures: If a service is permanently down or has a major outage.
Test Your Knowledge!
Which scenario is generally a good candidate for applying the Retry Pattern?
Retry Pattern Summary
You've learned the fundamentals of the Retry Pattern!
- It's for automatically re-attempting failed operations.
- It's crucial for handling transient failures in distributed systems.
- Basic implementation involves a loop with a maximum number of attempts.
- Adding delays (fixed or exponential backoff) is key to giving systems time to recover.
- Know when to use it (e.g., network issues) and when to avoid it (e.g., non-transient errors, non-idempotent operations).
Next, we'll explore other resilience patterns like fallbacks and timeouts!
常见问题解答
「重试模式基础」课时是免费的吗？
是的 — 「重试模式基础」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Microservices Communication Patterns (Saga, Circuit Breaker) 课程的其余内容，请升级到 CoddyKit PRO。 Microservices Communication Patterns (Saga, Circuit Breaker) 课程共包含 4 节课。
「重试模式基础」这节课中我会学到什么？
学习重试模式的基础知识，自动重新尝试失败的操作，提高系统健壮性。 你通过在浏览器中直接运行的动手代码来练习 Microservices Communication Patterns (Saga, Circuit Breaker)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Microservices Communication Patterns (Saga, Circuit Breaker) 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Microservices Communication Patterns (Saga, Circuit Breaker) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「重试模式基础」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Microservices Communication Patterns (Saga, Circuit Breaker) 课中编写并运行代码吗？
能。每节 Microservices Communication Patterns (Saga, Circuit Breaker) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。