ඔබේ C# යෙදුමක API ඇමතුමක් අසාර්ථක වූ විට, බොහෝ සංවර්ධකයන් "while(true)" ලූපයක් භාවිතා කරයි. එය සුළු තත්කාලික දෝෂයක් වුවත්, තත්පරයකට දසදහසක් ඇමතුම් නිර්මාණය කරලා සේවාදායකය බිඳ දමයි. මේ "retry storm" ගැන මේ ලිපියේ විස්තරය.
දෝෂයක් සිදු වූ විට, TCP RST වැනි වේගවත් පිළිතුරක් මිනිත්තු කීපයකින් පමණ ලැබේ. එම වේගවත් පිළිතුර නිසා ලූපය තවත් තවත් ඉක්මනින් පණිවුඩයක් යවයි. 5,000 ක් පමණ client එකක් එක්සේම එකම සේවාදායකයට අමතරයෙන් මිනිත්තුකට මිලියන ගණනක් ඇමතුම් එවන විට, සොකට්, TLS handshake, thread‑pool වැනි සම්පත් පවා බරපතල වේ. එම නිසා සේවාදායකය අඩු වීමට පත් වෙයි, එතැනින් පසු සාර්ථක ඇමතුමක් පවා නොලැබේ.
නිශ්චල කාලය (fixed delay) පමණක් භාවිතා කිරීම සරල විසඳුමක් වුවත්, එය thread‑pool එක අගුළු දමා දෝෂය තවත් පවතී. එමඟින් සියලු client එකම වේලාවේ “ඇවිලීම” සිදු කරයි, එම නිසා සර්වර් එකට එකවර ඉල්ලීම් ගොඩක් පැමිණෙයි. ඒත් exponential backoff + jitter ක්රමය භාවිතා කරන විට, අයදුම්පත් අතර කාලය අතිශයින් වෙනස් වෙයි, ඒ නිසා “herd effect” අඩු වේ.
ශ්රී ලංකාවට ඇති වැදගත්කම
ශ්රී ලංකාවේ තාක්ෂණික පාඨමාලා, startup ගෝලීය සේවාවන්, සහ IT සමාගම් සියලුම දේම API‑වලට බොහෝ විට විශ්වාස කරති. නිවැරදි retry යාමක් නොමැතිව, ඉහළ traffic එකක් සේවාදායකය බිඳ දමා, පාරිභෝගික අත්දැකීම අඩුවේ. මෙය පළපුරුදු ශ්රී ලංකා සංවර්ධකයින්ට:
- ඉගෙනුම් පාඨමාලා වලදී exponential backoff සහ jitter කුමනදැයි පැහැදිළි කරගත හැක.
- startup ගෝලීය API‑වලට සම්බන්ධ වන විට, සේවා නාමාවලිය ස්ථායිව පවත්වා ගැනීමට අවශ්ය වේ.
- ව්යාපාරික IT පද්ධතිවලදී, අධික retry traffic නිසා සිදුවන downtime අවම කර ගත හැක.
ඉදිරියට, C# HttpClient භාවිතා කරන සෑම සංවර්ධකයෙකුම පහත කේතය ඇතුළත් කරගත යුතුය:
static async Task<HttpResponseMessage> GetWithRetryAsync(HttpClient client, string url, CancellationToken ct)
{
const int maxAttempts = 5;
var baseDelay = TimeSpan.FromMilliseconds(200);
var maxDelay = TimeSpan.FromSeconds(20);
for (var attempt = 1;; attempt++)
{
try
{
var response = await client.GetAsync(url, ct);
if (!IsTransient(response.StatusCode) || attempt == maxAttempts) return response;
response.Dispose();
}
catch (HttpRequestException) when (attempt < maxAttempts) { }
catch (TaskCanceledException) when (!ct.IsCancellationRequested && attempt < maxAttempts) { }
var ceiling = Math.Min(maxDelay.TotalMilliseconds, baseDelay.TotalMilliseconds * Math.Pow(2, attempt - 1));
await Task.Delay(TimeSpan.FromMilliseconds(Random.Shared.NextDouble() * ceiling), ct);
}
}
මෙම කේතය exponential backoff සහ jitter එකතු කරයි, එයින් retry storm එකක් සිදුවීම අඩුවේ. ඉදිරියේදී, ඔබේ API‑වල reliability වැඩිවෙයි, පාරිභෝගික තෘප්තියත් ඉහළ යයි.
අවසන් වශයෙන්, retry logic එක සැලැස්වීමේදී සරල “wait 1 second” යන විකල්පය නොව, exponential backoff + jitter යොදා ගැනීම අත්යවශ්ය බව අවධාරණය කරමු. එමඟින් ශ්රී ලංකාවේ තාක්ෂණික පරිසරය තවත් ශක්තිමත් වනු ඇත.
