#Mutex

@scitechnews.bsky.social

1 month ago

Are Atomic Operations Faster and Better Than a Mutex? It Depends Exploring the differences between atomic operations and mutexes in Go, including performance benchmarks and use-case trade-offs.

madflojo.dev/posts/are-at... #Mutex

0 0 0 0

Chris https://youtube.com/@chrislinnett3235?si=GKzf7s1sJuX2amjX

@chrisl86.bsky.social

2 months ago

#banMusk
#banX
#boycottMusk
#boycottX
#muteMusk
#muteX

1 0 0 0

Chris https://youtube.com/@chrislinnett3235?si=GKzf7s1sJuX2amjX

@chrisl86.bsky.social

2 months ago

100% ban it NOW
#banMusk
#BoycottMusk
#banX
#BoycottX
#MuteMusk
#MuteX

0 0 0 0

Chris https://youtube.com/@chrislinnett3235?si=GKzf7s1sJuX2amjX

@chrisl86.bsky.social

2 months ago

#banmusk
#banX
#boycottmusk
#boycottX
#muteMusk
#muteX

2 0 0 0

ProgrammerHumor.io

@programmerhumor-io.bsky.social

2 months ago

Mutex Will Save You All

Mutex Will Save You All

#Mutex #Deadlock #Concurrency #multithreading #Raceconditions

programmerhumor.io/programming-memes/mutex-...

1 0 1 0

サードニュース@相互フォロー100%

@new3rd.bsky.social

3 months ago

AIレセプト業務支援プラットフォーム「Reze」が新たに6000万円の資金調達を実施 医療業界の深刻な経営課題解決に向け、株式会社mutexがAIを活用したレセプト業務支援サービス「Reze」の資金調達を行いました。

AIレセプト業務支援プラットフォーム「Reze」が新たに6000万円の資金調達を実施 #東京都 #文京区 #mutex #Reze #AIレセプト

医療業界の深刻な経営課題解決に向け、株式会社mutexがAIを活用したレセプト業務支援サービス「Reze」の資金調達を行いました。

0 0 0 0

Snapp iOS Weekly

@snappiosweekly.bsky.social

7 months ago

Modern Swift Lock: Mutex & the Synchronization Framework Learn how a Swift lock can help you create thread-safe access to data as an alternative to actors in Swift Concurrency.

🔒 𝘔𝘰𝘥𝘦𝘳𝘯 𝘚𝘸𝘪𝘧𝘵 𝘓𝘰𝘤𝘬: 𝘔𝘶𝘵𝘦𝘹 & 𝘵𝘩𝘦 𝘚𝘺𝘯𝘤𝘩𝘳𝘰𝘯𝘪𝘻𝘢𝘵𝘪𝘰𝘯 𝘍𝘳𝘢𝘮𝘦𝘸𝘰𝘳𝘬 by @avanderlee.com

This article explores 𝘔𝘶𝘵𝘦𝘹 as a lightweight alternative to actors for thread-safe operations in Swift.

#Swift #Concurrency #Mutex

2 0 0 0

サードニュース@相互フォロー100%

@new3rd.bsky.social

7 months ago

「Reze」による医療業務のデジタル変革と未来の医療を考える 株式会社mutexが新たにリリースしたAIレセプト管理ツール「Reze」が、医療機関の業務を効率化し、デジタル化の未来を切り開く。レセプト自動化の取り組みとその意義に迫る。

「Reze」による医療業務のデジタル変革と未来の医療を考える #東京都 #文京区 #医療DX #レセプト管理 #mutex

株式会社mutexが新たにリリースしたAIレセプト管理ツール「Reze」が、医療機関の業務を効率化し、デジタル化の未来を切り開く。レセプト自動化の取り組みとその意義に迫る。

0 0 0 0

DEV Community

@dev.to.web.brid.gy

10 months ago

Interior Mutability, Smart Pointers, and Tree Structures in Rust When writing system-level code or complex data structures like trees and graphs in Rust, one challenge quickly becomes apparent: how do you **share** and **mutate** data across many parts of a program **without sacrificing memory safety**? Rust’s ownership system doesn’t allow multiple `&mut` references or shared ownership by default. But the standard library offers powerful tools to overcome this — while maintaining safety guarantees. In this post, we explore some of Rust’s most important tools for working with shared, recursive, and mutable data structures: * `Box<T>` * `Rc<T>` / `Arc<T>` * `RefCell<T>` / `Mutex<T>` * `Weak<T>` We use a tree structure as our running example and discuss real-world system programming, GUIs, and interpreters. ## 📆 Box: Owning Recursive Types struct TreeNode { value: i32, left: Option<Box<TreeNode>>, right: Option<Box<TreeNode>>, } ### 🔍 Why Use Box? * Enables **recursive types** by storing nodes on the heap * Only allows **single ownership** (no sharing) ### ✅ When to Use: * Heap allocation for simple trees, linked lists * No need for shared or mutable access * **Example** : Binary tree leaves in a compiler, simple DOM nodes in a web renderer ## ♻️ Rc and RefCell: Shared & Mutable Trees use std::rc::Rc; use std::cell::RefCell; type NodeRef = Rc<RefCell<Node>>; struct Node { value: i32, children: Vec<NodeRef>, } impl Node { fn new(value: i32) -> NodeRef { Rc::new(RefCell::new(Node { value, children: vec![] })) } } ### 🔍 Why Combine Rc + RefCell? * `Rc<T>` enables **shared ownership** * `RefCell<T>` enables **interior mutability** , allowing mutation even through `&self` ### ✅ When to Use: * Build **tree or graph** structures * Allow many owners to **read and mutate** data * **Example** : GUI widget trees (`druid`, `iced`), ASTs for interpreters ### ⚠️ Memory Leaks Warning `Rc` uses reference counting — but **cannot detect cycles**! If two `Rc`s reference each other, they’ll leak memory. ## 🧰 Weak: Breaking Cycles Safely use std::rc::{Rc, Weak}; use std::cell::RefCell; struct Node { parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } ### 🔍 Why Use Weak? * `Weak<T>` is a **non-owning** reference * Does **not increase** the strong reference count * Prevents cyclic leaks between parent and child nodes ### ✅ When to Use: * Parent pointers in trees * Bidirectional linked structures * **Example** : Filesystem directory trees, scene graphs ## 🔐 Mutex and Arc: Thread-Safe Shared State When moving to multithreading, `Rc` and `RefCell` aren't enough. Instead, use: use std::sync::{Arc, Mutex}; let data = Arc::new(Mutex::new(vec![1, 2, 3])); let cloned = data.clone(); std::thread::spawn(move || { let mut locked = cloned.lock().unwrap(); locked.push(4); }); ### 🔍 Why Use Arc + Mutex? * `Arc<T>` = **atomic reference counted** smart pointer (safe across threads) * `Mutex<T>` = **exclusive mutable access** with runtime locking ### ✅ When to Use: * Share state between threads * Build concurrent task queues, database caches * **Example** : Shared blockchain ledger across network threads ## ✅ Summary: Choose the Right Tool Tool | Ownership | Mutability | Thread-Safe? | Example ---|---|---|---|--- Box | Single | No | ❌ | Recursive tree node Rc | Shared (single-threaded) | No | ❌ | AST nodes RefCell | Interior | Yes (runtime check) | ❌ | Cache inside Rc Arc | Shared (multi-threaded) | No | ✅ | Multithreaded P2P socket pool Mutex | Exclusive | Yes (lock) | ✅ | Task queue, ledger state Weak | Non-owning | Read-only unless upgraded | ✅ | Break cycles (parent-child trees) # 🧐 Final Thoughts Understanding `Box`, `Rc`, `RefCell`, `Arc`, `Mutex`, and `Weak` is **essential** if you want to write serious system-level Rust. These tools aren't "cheating" Rust’s rules — they are **specialized, powerful, safe ways** to express complicated relationships (ownership, sharing, mutation, concurrency) **while keeping the Rust safety guarantees**. With these patterns, you can build: * Blockchain nodes * Compilers * Embedded device controllers * Multithreaded servers * Real-time operating systems (RTOS) > **Master these — and you master Rust system programming.**

0 0 0 0

Forem

@forem.com.web.brid.gy

10 months ago

Interior Mutability, Smart Pointers, and Tree Structures in Rust When writing system-level code or complex data structures like trees and graphs in Rust, one challenge quickly becomes apparent: how do you **share** and **mutate** data across many parts of a program **without sacrificing memory safety**? Rust’s ownership system doesn’t allow multiple `&mut` references or shared ownership by default. But the standard library offers powerful tools to overcome this — while maintaining safety guarantees. In this post, we explore some of Rust’s most important tools for working with shared, recursive, and mutable data structures: * `Box<T>` * `Rc<T>` / `Arc<T>` * `RefCell<T>` / `Mutex<T>` * `Weak<T>` We use a tree structure as our running example and discuss real-world system programming, GUIs, and interpreters. ## 📆 Box: Owning Recursive Types struct TreeNode { value: i32, left: Option<Box<TreeNode>>, right: Option<Box<TreeNode>>, } ### 🔍 Why Use Box? * Enables **recursive types** by storing nodes on the heap * Only allows **single ownership** (no sharing) ### ✅ When to Use: * Heap allocation for simple trees, linked lists * No need for shared or mutable access * **Example** : Binary tree leaves in a compiler, simple DOM nodes in a web renderer ## ♻️ Rc and RefCell: Shared & Mutable Trees use std::rc::Rc; use std::cell::RefCell; type NodeRef = Rc<RefCell<Node>>; struct Node { value: i32, children: Vec<NodeRef>, } impl Node { fn new(value: i32) -> NodeRef { Rc::new(RefCell::new(Node { value, children: vec![] })) } } ### 🔍 Why Combine Rc + RefCell? * `Rc<T>` enables **shared ownership** * `RefCell<T>` enables **interior mutability** , allowing mutation even through `&self` ### ✅ When to Use: * Build **tree or graph** structures * Allow many owners to **read and mutate** data * **Example** : GUI widget trees (`druid`, `iced`), ASTs for interpreters ### ⚠️ Memory Leaks Warning `Rc` uses reference counting — but **cannot detect cycles**! If two `Rc`s reference each other, they’ll leak memory. ## 🧰 Weak: Breaking Cycles Safely use std::rc::{Rc, Weak}; use std::cell::RefCell; struct Node { parent: RefCell<Weak<Node>>, children: RefCell<Vec<Rc<Node>>>, } ### 🔍 Why Use Weak? * `Weak<T>` is a **non-owning** reference * Does **not increase** the strong reference count * Prevents cyclic leaks between parent and child nodes ### ✅ When to Use: * Parent pointers in trees * Bidirectional linked structures * **Example** : Filesystem directory trees, scene graphs ## 🔐 Mutex and Arc: Thread-Safe Shared State When moving to multithreading, `Rc` and `RefCell` aren't enough. Instead, use: use std::sync::{Arc, Mutex}; let data = Arc::new(Mutex::new(vec![1, 2, 3])); let cloned = data.clone(); std::thread::spawn(move || { let mut locked = cloned.lock().unwrap(); locked.push(4); }); ### 🔍 Why Use Arc + Mutex? * `Arc<T>` = **atomic reference counted** smart pointer (safe across threads) * `Mutex<T>` = **exclusive mutable access** with runtime locking ### ✅ When to Use: * Share state between threads * Build concurrent task queues, database caches * **Example** : Shared blockchain ledger across network threads ## ✅ Summary: Choose the Right Tool Tool | Ownership | Mutability | Thread-Safe? | Example ---|---|---|---|--- Box | Single | No | ❌ | Recursive tree node Rc | Shared (single-threaded) | No | ❌ | AST nodes RefCell | Interior | Yes (runtime check) | ❌ | Cache inside Rc Arc | Shared (multi-threaded) | No | ✅ | Multithreaded P2P socket pool Mutex | Exclusive | Yes (lock) | ✅ | Task queue, ledger state Weak | Non-owning | Read-only unless upgraded | ✅ | Break cycles (parent-child trees) # 🧐 Final Thoughts Understanding `Box`, `Rc`, `RefCell`, `Arc`, `Mutex`, and `Weak` is **essential** if you want to write serious system-level Rust. These tools aren't "cheating" Rust’s rules — they are **specialized, powerful, safe ways** to express complicated relationships (ownership, sharing, mutation, concurrency) **while keeping the Rust safety guarantees**. With these patterns, you can build: * Blockchain nodes * Compilers * Embedded device controllers * Multithreaded servers * Real-time operating systems (RTOS) > **Master these — and you master Rust system programming.**

0 0 0 0

Mr. Gregeffrey

@mrgregeffrey.bsky.social

11 months ago

MuTeX on Battle Beaver’s Magneto Mechanisms (TMR) – Deadzone & Recoil Perfected? YouTube video by Battle Beaver Customs

Get those Magneto Mechs at Battle Beaver! I currently have them in my XSX controller, and they're the smoothest feeling thumbsticks I've ever had.
battlebeavercustoms.com

Here's #MuTeX playing with his controller, fitted with the Magnetos
youtu.be/KEp3tPqTYAo?...

1 0 0 0

alexanderadam

@alexanderadam.ruby.social.ap.brid.gy

11 months ago

Anton Maminov (@mamantoha@ruby.social) 13 Posts, 48 Following, 18 Followers · Linux guy, Ruby developer, Crystal enthusiast. #StandWithUkraine 🇺🇦

Nice read! @mamantoha published a short and nice ✍️ blog post about 🚥 #semaphores in :crystal: #crystal at @thepracticaldev:

https://dev.to/mamantoha/semaphores-in-crystal-5eha

#CrystalLang #CrystalLanguage #concurrency #waitgroup #mutex #parallel #paralellism #concurrency #programming

0 0 0 0

LaTeclaESC

@lateclaescape.bsky.social

1 year ago

Los mutex Articulo disponible en formato audiblog: Introducción En un entorno de programación concurrente, varios hilos de ejecución pueden intentar acceder a un mismo recurso...

Los mutex permiten solucionar el problema de las race condition en programación concurrente. En este articulo te explico como usarlos correctamente.

www.lateclaescape.com/post/2025/mu...

#Mutex #raceconditions #pthread #concurrencia

0 0 0 0

̧̧̧̥̦̃Ḁ̧̧̧̦̥̣̦̦̃̂ĉ̥̣̦̦̤́̂̀í̤̦̂̀́̀D̦̦́̀̀B̦̥̀̂̃ŷ̧̥̤̦̃̃ţ̤̦̤̣̃̃̂̂ẽ̤

@acidbyte.bsky.social

1 year ago

A quick question for #Arduino enthusiasts: Have you ever used the #FreeRTOS #API? Were you satisfied with it? I tested the #MP #Mutex API from #Spresense and found it quite clear and easy to use.

0 0 0 0

FunctionalProgramming

@functionalprogramming.activitypub.awakari.com.ap.brid.gy

1 year ago

Awakari App

Why can't I assign an std::optional of std::lock_guard? Why can't I declare an optional s...

stackoverflow.com/questions/79413828/why-c...

#c++ #c++17 #mutex #stdoptional #lock-guard

Event Attributes

0 0 0 0

Antonio Sanz

@antoniosanzalc.bsky.social

14 years ago

Blinda tu #wordpress con #mutex : Detector de intrusos en PHP con panel de administración en WP ... #seguridad appsweb

0 0 0 0

Posts tagged #Mutex