Shared ownership (Rc & Arc)Concept

Explanation

Neither Rc<T> nor Arc<T> lives in core — both are defined in alloc, so using either at all requires extern crate alloc; plus a #[global_allocator] configured for the target; on a bare #![no_std] project with no allocator, Rc::new/Arc::new simply don't compile. That much is the same "needs alloc" caveat as Box.

The more honest caveat is about whether reaching for either is the right move even once alloc is available. Rc's whole value proposition — non-atomic, single-threaded reference counting — only pays for itself when there's a genuine multi-owner story: several independent parts of a program, none of which is clearly "the" owner, that outlive individual function scopes. That shape does happen in embedded code (a shared config struct read by several long-lived subsystems, for instance), but the other classic reason to reach for Rc/Arc on a hosted target — "this needs to survive being handed to a spawned OS thread whose lifetime the compiler can't otherwise reason about" — usually doesn't apply on bare metal, because there's rarely an OS thread being spawned in the first place. What embedded code does have instead is an interrupt boundary: state shared between main's loop and one or more #[interrupt] handlers. For that specific, extremely common case, the idiomatic solution isn't Rc/Arc at all — it's a 'static critical_section::Mutex<RefCell<T>>, which needs no heap, no reference counting, and no allocator, because the value has exactly one place it lives (a static) and the Mutex only governs when code is allowed to touch it, not how many owners it has. Reach for Rc/Arc in embedded code specifically when the multi-owner shape is real (and alloc is already configured for other reasons) — not as a reflexive substitute for sharing state with an interrupt handler.

Basic usage example

use core::cell::RefCell;
use critical_section::Mutex;

// The idiomatic embedded default for state shared across the interrupt
// boundary: no alloc, no reference counting, one static owner.
static CONFIG: Mutex<RefCell<u32>> = Mutex::new(RefCell::new(9600)); // <- 'static value, not an Rc/Arc

fn set_baud(new_baud: u32) {
    critical_section::with(|cs| {
        *CONFIG.borrow_ref_mut(cs) = new_baud;
    });
}

Best practices & deeper information

use core::cell::RefCell;
use critical_section::Mutex;

static BAUD_RATE: Mutex<RefCell<u32>> = Mutex::new(RefCell::new(9600)); // <- one static owner, not a reference count

#[interrupt]
fn CONFIG_UPDATE() {
    critical_section::with(|cs| {
        *BAUD_RATE.borrow_ref_mut(cs) = 115_200;
    });
}

fn main_loop_read() -> u32 {
    critical_section::with(|cs| *BAUD_RATE.borrow(cs))
}

// Illustrative: an RTOS/std-capable embedded target (e.g. ESP-IDF with std support)
use std::sync::{Arc, Mutex};
use std::thread;

let shared_reading = Arc::new(Mutex::new(0.0_f32));

let worker = {
    let shared_reading = Arc::clone(&shared_reading); // <- genuine second owner: a real OS thread
    thread::spawn(move || {
        *shared_reading.lock().unwrap() = 21.4;
    })
};

worker.join().unwrap();
println!("{}", *shared_reading.lock().unwrap());