#concurrency

John AckeeseedJohnAckeeseed
2025-07-08

🚀 Swift 6.2 Tip! All SwiftUI Views are now implicitly @MainActor isolated.

Got a warning using a View property inside a @Sendable closure? That's because it might run on a background thread.

The fix: Explicitly capture a copy of the property 💡

JAVAPROjavapro
2025-07-07

Klassische Threads stoßen in schnell an Ressourcenlimits & machen Fehlerbehandlung komplex. in versprechen Skalierbarkeit & klarere -Konzepte.

Nutze die Vorteile im eigenen Code. Lese Merlin Bögershausens Artikel: javapro.io/de/mehr-action-mehr

Piotrek Jeremiczpiotrekjeremicz
2025-07-04

The desire to use must be clearly indicated in the code. Without this, MainActor isolation ensures your code always runs on the main thread.

Even if you use an external API that sends tasks to the background, the code will eventually return to the main thread.

3/5

2025-07-02

He’ll explain what Rust’s ordering rules (`Relaxed`, `Acquire`, `SeqCst`, etc.) actually mean, and how they show up in the concurrency crates you use every day.

➡️ eurorust.eu/talks/rusts-memory

#RustLang #Concurrency #MemoryModel

🧵 2/3

Gareth Lloyd (He/him)glloyd@fosstodon.org
2025-06-23

I am playing with #libstdexec, I used a static thread pool and bulk. The problem is that the workload is not uniform. For some inputs, there is next to no work to be done.
When this happens, the mechanism inside the scheduler is dominating my profiling.
What I really want is something like adaptive workload splitting.

Any ideas? #cpp #cplusplus #programming #concurrency

2025-06-17

Concurrency Concept: Say you have two threads trying to access the same bytes.
Instead of a lock, both threads can reserve a specific time interval, in which they are allowed to access the memory area. So the access timeline would look something like this (t1 and t2 being the timeframe's the respective threads can access it): t1 | t2 | t1 | t2 | ...

2025-06-17

"The best way to approach concurrency is to master the fundamentals" #scala #concurrency lukastymo.com/posts/022-concur

Jan :rust: :ferris:janriemer@floss.social
2025-06-14

@noboilerplate THIS!

I think a lot of people inadvertently assume async #RustLang is so different from sync Rust, because the way it is - when in fact it's because of the (most popular) async runtime they're using.

We should look way more into alternative #async runtimes to #Tokio, e.g. smol:

floss.social/@janriemer/111669

#Smol allows you to use non-'static Futures by using a local executor:

floss.social/@janriemer/111669

It looks a lot more like "normal" #Rust.

#RustAsync #AsyncRust #Concurrency

Jonathan Joelsonjjoelson
2025-06-11

Paging experts! Is there any way to leverage KVO to synchronously update a property in one class in response to a change in another?

Note that both `MyClass` and `AVPlayer` are `@MainActor`, so I think this should be a safe thing to want to do... I just don't know how to do it!

cc @mattiem

EDIT: is this a good use case for `MainActor.assumeIsolated`?

Example code:
```
@MainActor class MyClass {
    private let player = AVPlayer()
    private let observation: NSKeyValueObservation?
    
    private var isPlaying = false
    
    init() {
        observation = player.observe(\.timeControlStatus) { [weak self] object, _ in
            self?.isPlaying = object.timeControlStatus == .playing
        }
    }
}
```
Compiler error: "Main actor-isolated property 'isPlaying' can not be mutated from a Sendable closure"
2025-06-08

GPUMC: A Stateless Model Checker for GPU Weak Memory Concurrency

#OpenCL #CUDA #Concurrency #Memory #ModelCheck

hgpu.org/?p=29921

Hacker Newsh4ckernews
2025-06-08
2025-06-07

Discovering a JDK Race Condition, and Debugging It in 30 Minutes with Fray
aoli.al/blogs/jdk-bug/
#ycombinator #fray #concurrency_bug #concurrency #jdk

Client Info

Server: https://mastodon.social
Version: 2025.04
Repository: https://github.com/cyevgeniy/lmst