How to implement backpressure in async Rust

Implement backpressure in async Rust by using tokio_util::codec::Framed with a custom capacity or tokio::sync::mpsc channels with a bounded buffer.

use tokio::net::TcpStream;
use tokio_util::codec::{Framed, LengthDelimitedCodec};

async fn handle_connection(stream: TcpStream) {
    // Backpressure is applied when the internal buffer exceeds 64KB
    let framed = Framed::with_capacity(stream, LengthDelimitedCodec::new(), 64 * 1024);
    // ... use framed
}

Alternatively, use a bounded channel to limit in-flight messages:

use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::channel::<String>(100); // Max 100 items buffered
// ... send via tx, receive via rx

The Framed type automatically pauses reading when the write buffer hits backpressure_boundary, and mpsc::channel blocks the sender when the queue is full.

Backpressure stops your program from crashing when it receives data faster than it can process it. It works like a bucket with a hole: if you pour water in too fast, the bucket fills up and stops accepting more until you empty some out. In Rust, this prevents memory from filling up by pausing the sender or reader until the receiver catches up.