rust 13 lines · 1 tab

Channels (mpsc) for message passing between threads

Marcus Chen Jan 2026

1 tab

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

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        tx.send("hello from thread").unwrap();
    });

    let message = rx.recv().unwrap();
    println!("Received: {}", message);
}

1 file · rust Explain with highlit

Rust's mpsc (multiple producer, single consumer) channels are the safest way to communicate between threads. You send owned values through the channel, transferring ownership to the receiver. This prevents data races because only one thread owns the data at a time. The sender can be cloned for multiple producers, and the receiver blocks or returns Err when all senders are dropped. I use channels for worker pools, event loops, and anywhere I need backpressure or decoupling. The pattern is similar to Go's channels but with Rust's ownership guarantees. For more complex topologies, I reach for crossbeam or tokio::sync, but mpsc covers most use cases and is part of the standard library.

Related snips

rust

struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing

by Marcus Chen 1 tab

rust

use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free

by Marcus Chen 1 tab

javascript

// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
  const success = true;

  setTimeout(() => {
    if (success) {

Promises and async/await patterns for asynchronous JavaScript

javascript promises async-await

by Alex Chang 1 tab

rust

use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing

by Marcus Chen 1 tab

rust

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    #[arg(short, long)]

clap for CLI argument parsing with derive macros

rust cli clap

by Marcus Chen 1 tab

typescript

export type Settled<R> =
  | { status: 'fulfilled'; value: R }
  | { status: 'rejected'; reason: unknown };

export interface ConcurrencyOptions {
  limit: number;

Simple concurrency limiter for batch operations

node concurrency async

by codesnips 2 tabs

Share this code

Here's the card — post it anywhere.

Channels (mpsc) for message passing between threads — share card

Link copied