rust 19 lines · 1 tab

Send and Sync traits for safe concurrency guarantees

Marcus Chen Jan 2026

1 tab

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));

    let handles: Vec<_> = (0..3)
        .map(|_| {
            let data_clone = Arc::clone(&data);
            thread::spawn(move || {
                data_clone.lock().unwrap().push(4);
            })
        })
        .collect();

    for h in handles {
        h.join().unwrap();
    }
}

1 file · rust Explain with highlit

Send means a type can be transferred across thread boundaries. Sync means a type can be shared between threads (&T is Send). Most types are Send + Sync; exceptions include Rc (not Send) and RefCell (not Sync). The compiler uses these marker traits to prevent data races at compile time. You rarely implement them manually; they're auto-derived when all fields are Send/Sync. For unsafe code that maintains invariants manually, you can implement them explicitly. Understanding Send and Sync is key to Rust's fearless concurrency: the type system prevents accidental data sharing. This is what makes Arc<Mutex<T>> safe: Arc is Send + Sync, Mutex ensures exclusive access.

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 std::sync::mpsc;
use std::thread;

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

Channels (mpsc) for message passing between threads

rust concurrency channels

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

Share this code

Here's the card — post it anywhere.

Send and Sync traits for safe concurrency guarantees — share card

Link copied