# How Meetily Implements the `Arc>` Thread Safety Pattern for Async Recording Tasks > Discover how Meetily implements Arc> for thread-safe async recording. Learn to share mutable state with concurrent reads and exclusive writes efficiently. - Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily) - Tags: internals - Published: 2026-07-10 --- **Meetily uses `Arc>` to share mutable recording state across asynchronous tasks, allowing multiple concurrent readers while serializing exclusive writes for configuration changes.** Meetily's audio subsystem coordinates several asynchronous tasks—microphone capture, VAD, transcription, and UI listeners—that must access common recording state without data races. The Rust-based backend solves this by wrapping shared mutable data in `Arc>`, combining shared ownership with reader-writer locking semantics. This pattern appears throughout the codebase, from the core `RecordingState` struct to service-level caches in the Whisper engine. ## Why `Arc>` Is Used in Meetily's Audio Pipeline Rust's ownership model requires explicit mechanisms for sharing mutable state across asynchronous boundaries. Meetily employs two complementary primitives: ### Shared Ownership with `Arc` The `Arc` (Atomic Reference Counting) smart pointer enables multiple async tasks to hold ownership of the same underlying data. When `RecordingState::new` creates the top-level state, it returns `Arc`, allowing each spawned task to receive its own clone while the data lives as long as any reference exists. ### Concurrent Access with `RwLock` `RwLock` provides a read-write lock that distinguishes between read and write operations. Multiple tasks can acquire read locks simultaneously for high-throughput paths like checking recording status, while write locks serialize exclusive access during pipeline reconfiguration or error handling. This prevents the contention that would occur with a `Mutex`, where every access—even read-only queries—would block other tasks. ## Implementation in `RecordingState` The core state management lives in [`frontend/src-tauri/src/audio/recording_state.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_state.rs). Here, the struct is instantiated as an `Arc` at line 30-33, with the `new()` method returning `Arc`: ```rust // recording_state.rs pub fn new() -> Arc { Arc::new(Self { // initialization... }) } ``` While simple fields use `Atomic*` types for lock-free updates, complex mutable structures like audio channels are wrapped in `Mutex` or `RwLock`. When the recording pipeline needs to swap the audio sender channel, it acquires a write lock: ```rust // Replace the audio sender when rebuilding the pipeline { let mut sender_lock = recording_state.audio_sender.lock().unwrap(); *sender_lock = Some(new_sender); } ``` ## Service-Level State Management Beyond the core recording state, higher-level services use `Arc>` for their own caches. In [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) (lines 38-45), the engine maintains several fields wrapped in `Arc>` to allow the transcription task to update model states while other tasks query progress. The parallel processor in [`frontend/src-tauri/src/whisper_engine/parallel_processor.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/parallel_processor.rs) demonstrates this pattern with a task queue: ```rust // Shared queue for audio chunks let queue: Arc> = Arc::new(RwLock::new(ChunkQueue::new())); // Spawn worker tasks that clone the Arc let worker = tokio::spawn(process_chunks(queue.clone())); ``` ## Practical Usage Pattern The orchestration happens in [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs), which passes the shared `Arc` to each async worker. Tasks follow a distinct pattern for read versus write operations: **Read-heavy paths** (status checks, statistics gathering) use read locks that don't block each other: ```rust // Fast-path read: many tasks can execute this concurrently if recording_state.is_active() { // Continue processing audio... } ``` **Write operations** (configuration changes, error handling) acquire exclusive locks briefly to minimize blocking: ```rust // Update error counters or swap channels { let mut state = shared_state.write().unwrap(); state.error_count += 1; state.last_error = Some(error); } // Lock drops here, unblocking readers ``` Because the `RwLock` allows concurrent reads, the audio pipeline remains responsive even when multiple tasks query state simultaneously, while exclusive writes ensure configuration changes happen atomically. ## Summary - **Meetily** uses `Arc>` in [`recording_state.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/recording_state.rs) to share ownership of mutable recording state across async tasks. - **Read locks** enable concurrent access for status checks and statistics, while **write locks** serialize exclusive mutations during pipeline changes. - **`RecordingState::new`** returns `Arc`, with internal fields using `Atomic*` for simple values and `RwLock` for complex mutable structures like audio channels. - **Service-level components** in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) and [`parallel_processor.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/parallel_processor.rs) apply the same pattern for model caches and chunk queues. - The combination prevents data races while maintaining high throughput, avoiding the "reader-writer" bottleneck of a global mutex. ## Frequently Asked Questions ### What is the advantage of using `RwLock` instead of `Mutex` for shared state? `RwLock` allows multiple readers to access data simultaneously, whereas `Mutex` grants exclusive access to one task regardless of whether it needs to read or write. In Meetily's audio pipeline, where many tasks frequently check recording status (reads) but only occasionally update configuration (writes), `RwLock` provides better concurrency and prevents unnecessary blocking of read-only operations. ### Where does Meetily create the shared `Arc` instance? The instance is created in [`frontend/src-tauri/src/audio/recording_state.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_state.rs) within the `new()` method, which returns `Arc` rather than a plain struct. This ensures that from the moment of creation, the state is reference-counted and ready to be cloned into multiple async tasks spawned by the recording manager. ### How does Meetily handle write operations without blocking the entire audio pipeline? Write operations acquire the `RwLock` exclusively but hold it for brief, scoped durations—typically using block scopes or explicit drop points. This ensures that even when swapping audio channels or updating error states in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs), the lock is released immediately after the mutation, allowing waiting readers to proceed without stalling the entire system.