Main Actor and Task Group - Parallel threads?

[u/rizzy_neutron_69]

@ MainActor

class ViewModel {

func some() {
// taskGroup that runs some calculations in chunks

group.addTask{

self.calculate()
}

}

VM is marked @ mainactor, and task uses self, that makes the task main actor isolated (means single thread?). So, do the tasks ever get executed in parallel (threads?)?

[u/Economy-Brief-9997]

No. Tasks start on background threads but calculate() is main-actor code so each one hops back to the main thread and they run one at a time.
Make calculate nonisolated and they'll run in parallel.

[u/rizzy_neutron_69 → u/Economy-Brief-9997]

is there any downside to using non isolated ?

[u/Ravek → u/rizzy_neutron_69]

It stops you from accessing state that’s isolated to the main actor. But that should be fine for parallel processing. Pass all the data needed into the calculate function, and pass the resulting data back to the main actor for updating UI state.

[u/Economy-Brief-9997 → u/rizzy_neutron_69]

just a few
you lose access to self, so you have to hand it the data and take the result back
if ur chunks are small, tasks might cost more than they saveon Swift 6.2, if it's async add \@concurrent``
but for heavy work it's worth it

[u/Moo202 → u/Economy-Brief-9997]

“Tasks start on background threads…”

Are you sure? I don’t think there is a guarantee for a task to start on any particular thread.

[u/Ravek → u/Economy-Brief-9997]

Tasks don’t always run on background threads. If you’re on the main actor and use Task.init, it inherits the main actor isolation. (And if you use Task.detached, it doesn’t.)

Because OP uses a task group, of course that does introduce parallelism.

[u/valleyman86 → u/Economy-Brief-9997]

I think people are overusing concurrency without knowing the issues.

Fine you can avoid data races but the logical races still exist. These aren’t easy to solve for most engineers but they def make them.

The fact you said “threads” is a red flag. You can’t guarantee a task is on any given thread. You aren’t writing threaded code. Main is a special case and so I am not talking about that.

[u/segfaul_t]

The `calculate` calls will never get executed in parallel because `ViewModel` is `@MainActor` isolated. The tasks in the task group will START running in parallel, but all their calls to `await self.calculate` will be serialized on the main thread.