--- title: Constructor acquires, destructor releases | daily.dev description: A deep dive into RAII (rebranded as CADR — Constructor Acquires, Destructor Releases) and how C++ and Rust handle concurrent access to shared state. Using a... canonical: https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Constructor acquires, destructor releases | daily.dev og:description: A deep dive into RAII (rebranded as CADR — Constructor Acquires, Destructor Releases) and how C++ and Rust handle concurrent access to shared state. Using a... og:url: https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n og:image: https://api.daily.dev/og/posts/BhhCqmH3n.png og:image:alt: Constructor acquires, destructor releases og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Constructor acquires, destructor releases **[Collabora Blog](https://daily.dev/sources/collabora)** · 9 min read · 0 upvotes · 0 comments ## Summary A deep dive into RAII (rebranded as CADR — Constructor Acquires, Destructor Releases) and how C++ and Rust handle concurrent access to shared state. Using a running example of a mutex-protected widget, the post shows how C++ provides CADR tools like std::scoped_lock but cannot enforce their use, leaving data races possible. Rust, by contrast, uses marker traits (Send and Sync), smart pointers (Arc, Mutex), and the borrow checker to make data races a compile-time error rather than a runtime surprise — what the Rust community calls 'fearless concurrency'. Mozilla's parallel CSS styling work is cited as a real-world example of Rust's concurrency guarantees enabling what C++ could not. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What is the difference between Rc and Arc in Rust and why can't I send Rc to another thread? Rc cannot be sent across threads because it is not Send — its internal reference counter is not atomic, so concurrent access from multiple threads would cause a data race on the counter itself. Arc (Atomic Reference Counting) uses an atomic counter, making it both Send and Sync, and is the correct choice when sharing ownership across threads. _Rust developers navigating ownership across threads keep up with these distinctions on daily.dev._ ### How does Rust's Mutex guarantee I can't access the inner value without locking it first? Rust's Mutex exposes the inner value only through a guard returned by lock(). There is no way to dereference the Mutex directly — the type system enforces that access to the wrapped value always goes through the guard, which holds the lock for its lifetime and releases it when dropped. This mirrors the CADR pattern but is baked into the language rather than left to programmer discipline. _Teams moving concurrent codebases from C++ to Rust track patterns like this on daily.dev._ ### What are the Send and Sync traits in Rust and how do they prevent data races? Send marks a type as safe to move between threads; Sync marks a type as safe to share references between threads. The Rust compiler automatically derives these markers based on a type's contents, so only authors of concurrency primitives need to implement them manually. Any attempt to share a non-Send or non-Sync type across threads is a compile-time error, making data races essentially impossible in safe Rust. _Developers building concurrent systems in Rust find real-world examples of these guarantees on daily.dev._ ## Similar posts on daily.dev - [Rust Prevents Data Races, Not Race Conditions](https://daily.dev/posts/rust-prevents-data-races-not-race-conditions-fjfi1lvd3) · corrode · 9 upvotes · 0 comments - [How we interfaced single-threaded C\+\+ with multi-threaded Rust](https://daily.dev/posts/how-we-interfaced-single-threaded-c-with-multi-threaded-rust-w9nznwtme) · Hacker News · 5 upvotes · 0 comments - [Beyond Memory Safety: What Makes Rust Different – Lessons from Autonomous Robotics](https://daily.dev/posts/beyond-memory-safety-what-makes-rust-different-lessons-from-autonomous-robotics-ivljxogzh) · InfoQ · 0 upvotes · 0 comments - [Beyond the &](https://daily.dev/posts/beyond-the--hhcrrsrh4) · Lobsters · 0 upvotes · 0 comments --- Tags: [#rust](https://daily.dev/tags/rust), [#c++](https://daily.dev/tags/c++) [View this post on daily.dev](https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Constructor acquires, destructor releases","url":"https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n"},"datePublished":"2026-08-11T08:54:28.364Z","dateModified":"2026-08-11T09:29:57.727Z","description":"A deep dive into RAII (rebranded as CADR — Constructor Acquires, Destructor Releases) and how C++ and Rust handle concurrent access to shared state. Using a...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/69c7024173e3cc415e077d8939f4af2a?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/69c7024173e3cc415e077d8939f4af2a?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Collabora Blog","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Collabora Blog","logo":"https://media.daily.dev/image/upload/s--ZGZ0FjqS--/f_auto,q_auto/v1786438306/logos/collabora?_a=BAMAMicg0","url":"https://daily.dev/sources/collabora"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"rust,c++","timeRequired":"PT9M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Collabora Blog","item":"https://daily.dev/sources/collabora"},{"@type":"ListItem","position":3,"name":"Constructor acquires, destructor releases"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/constructor-acquires-destructor-releases-bhhcqmh3n#faq","mainEntity":[{"@type":"Question","name":"What is the difference between Rc and Arc in Rust and why can't I send Rc to another thread?","acceptedAnswer":{"@type":"Answer","text":"Rc cannot be sent across threads because it is not Send — its internal reference counter is not atomic, so concurrent access from multiple threads would cause a data race on the counter itself. Arc (Atomic Reference Counting) uses an atomic counter, making it both Send and Sync, and is the correct choice when sharing ownership across threads. Rust developers navigating ownership across threads keep up with these distinctions on daily.dev."}},{"@type":"Question","name":"How does Rust's Mutex guarantee I can't access the inner value without locking it first?","acceptedAnswer":{"@type":"Answer","text":"Rust's Mutex exposes the inner value only through a guard returned by lock(). There is no way to dereference the Mutex directly — the type system enforces that access to the wrapped value always goes through the guard, which holds the lock for its lifetime and releases it when dropped. This mirrors the CADR pattern but is baked into the language rather than left to programmer discipline. Teams moving concurrent codebases from C++ to Rust track patterns like this on daily.dev."}},{"@type":"Question","name":"What are the Send and Sync traits in Rust and how do they prevent data races?","acceptedAnswer":{"@type":"Answer","text":"Send marks a type as safe to move between threads; Sync marks a type as safe to share references between threads. The Rust compiler automatically derives these markers based on a type's contents, so only authors of concurrency primitives need to implement them manually. Any attempt to share a non-Send or non-Sync type across threads is a compile-time error, making data races essentially impossible in safe Rust. Developers building concurrent systems in Rust find real-world examples of these guarantees on daily.dev."}}]} ```