One-Shot Channels for Task Completion

In this lesson, you will learn how to use one-shot channels to synchronize a main thread with a background task when that task finishes its work.

The Problem: Signaling Completion

When you spawn a thread, the thread returns a handle. While you could technically .join() that handle to wait for completion, that approach forces you to block the main thread waiting for the thread to exit entirely. Often, you simply need a lightweight signal to know when a specific, high-level task is "done" without needing the thread to terminate immediately.

The One-Shot Channel Solution

A one-shot channel (often provided by crates like tokio or oneshot) is a specialized communication primitive designed to send exactly one message from one sender to one receiver. Because it is optimized for a single transfer, it incurs significantly less overhead than full-featured multi-producer channels.

Think of it like a buzzer: the worker thread holds the "sender" half, and the main controller holds the "receiver" half. When the worker finishes its compute-intensive operation, it drops a result into the sender. The receiver, which has been waiting, immediately receives that notification.

use std::thread;
use std::sync::mpsc::channel;

fn main() {
    // We create a channel where only one message will ever be sent.
    let (tx, rx) = channel::<String>();

    thread::spawn(move || {
        // ... perform heavy lifting ...
        let result = "Task complete!".to_string();
        
        // Signal the controller that we are done.
        let _ = tx.send(result);
    });

    // Main thread is free to do other work, 
    // then it waits for the one-shot notification.
    let message = rx.recv().unwrap();
    println!("Received: {}", message);
}

Why use this over .join()?

Using a one-shot channel decouples the task logic from the thread lifecycle. If your worker thread is part of a long-running thread pool, you cannot call .join() on it, as that would kill the thread. With one-shot channels, you can signal "task done" repeatedly across the same thread's lifetime, allowing your controller to manage complex asynchronous workflows without managing individual thread handles.

Key Takeaway: One-shot channels provide a lightweight, single-use communication primitive that allows worker threads to signal task completion to a controller without binding the signal to the thread's physical exit.