Erlang OTP: Distributed & Fault-Tolerant Systems Programming · บทเรียน

รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน

รักษาเสถียรภาพของระบบขณะรับภาระเกินด้วยรูปแบบแรงดันย้อนกลับ การจำกัดอัตรา และการลดภาระงานที่สร้างบนโครงสร้างพื้นฐานของ OTP

บทเรียน 4 จาก 413 ขั้นตอน

รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน เป็นบทเรียน Erlang OTP: Distributed & Fault-Tolerant Systems Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Erlang OTP: Distributed & Fault-Tolerant Systems Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Erlang OTP: Distributed & Fault-Tolerant Systems Programming มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

What Is Backpressure?

When work arrives faster than a system can process it, queues grow and latency explodes. Backpressure is the practice of signalling producers to slow down so the system stays stable instead of melting down.

The Unbounded Queue Problem

An async gen_server:cast never blocks the caller, so its mailbox can grow without limit under load — the system runs out of memory before it ever rejects work.

Synchronous Calls as Backpressure

Using gen_server:call instead of cast makes the caller wait until the server is ready, naturally throttling producers to the server speed.

Reply = gen_server:call(worker, {process, Job}, 5000).

Bounded Queues

Maintain an explicit counter of in-flight work and reject or block new requests once a limit is reached, rather than letting the mailbox grow.

handle_call({job, J}, _From, #{n := N} = S) when N < 100 ->
    {reply, ok, S#{n := N + 1}};
handle_call({job, _}, _From, S) ->
    {reply, {error, overloaded}, S}.

Load Shedding

Under extreme load, the best move can be to shed low-priority work fast — returning an error immediately — to protect the system for high-priority requests.

Rate Limiting with Tokens

A token-bucket limiter grants a fixed number of permits per interval; requests beyond that wait or fail. This caps throughput predictably.

case take_token(Bucket) of
    ok -> do_work();
    empty -> {error, rate_limited}
end.

Measuring Pressure

The mailbox length of a bottleneck process is a live pressure gauge. Monitor it and trigger shedding before it grows dangerous.

process_info(Worker, message_queue_len).

Pooling for Throughput

A pool of worker processes (e.g. via poolboy) bounds concurrency: requests queue for a free worker, giving natural backpressure with controlled parallelism.

Circuit Breakers

When a downstream dependency is failing, a circuit breaker opens to stop sending requests for a cooldown period, preventing pileups and giving the dependency time to recover.

Timeouts as Protection

Always give gen_server:call a finite timeout. An unbounded wait lets a stuck server block callers indefinitely; a timeout converts a hang into a fast, recoverable error.

case catch gen_server:call(srv, req, 2000) of
    {ok, R} -> R;
    _ -> {error, busy}
end.

Choosing a Strategy

Combine patterns: synchronous calls for natural throttling, bounded queues to cap memory, rate limiting for fairness, and load shedding plus circuit breakers as last-resort protection.

Quick Check

Test your load regulation knowledge.

Recap

You learned to keep systems stable under overload:

  • Backpressure signals producers to slow down
  • Synchronous call throttles naturally; bounded queues cap memory
  • Rate limiting enforces fairness; load shedding protects priority work
  • Worker pools bound concurrency; circuit breakers stop downstream pileups
  • Monitor mailbox length as a live pressure gauge
เริ่มต้นได้ฟรี

เรียนรู้ Erlang ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
12
บทเรียน
48

คำถามที่พบบ่อย

บทเรียน “รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Erlang OTP: Distributed & Fault-Tolerant Systems Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Erlang OTP: Distributed & Fault-Tolerant Systems Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน”

รักษาเสถียรภาพของระบบขณะรับภาระเกินด้วยรูปแบบแรงดันย้อนกลับ การจำกัดอัตรา และการลดภาระงานที่สร้างบนโครงสร้างพื้นฐานของ OTP คุณปฏิบัติ Erlang OTP: Distributed & Fault-Tolerant Systems Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Erlang OTP: Distributed & Fault-Tolerant Systems Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Erlang OTP: Distributed & Fault-Tolerant Systems Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Erlang OTP: Distributed & Fault-Tolerant Systems Programming นี้ได้ไหม

ได้ บทเรียน Erlang OTP: Distributed & Fault-Tolerant Systems Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การออกแบบเพื่อความพร้อมใช้งานสูง
  2. รูปแบบฉันทามติแบบกระจาย
  3. กรณีศึกษาของ Erlang OTP
  4. รูปแบบแรงดันย้อนกลับและการควบคุมภาระงาน
← กลับไปที่ Erlang OTP: Distributed & Fault-Tolerant Systems Programming