[kazinator]

And then hit annoying roadblocks when you do want to pass those objects between threads?

You should write code to minimize the reference count bumps; they are waste of time whether atomic or not.

If the code spends 0.5% of its time bumping references, and you magically reduce that to zero using alien optimization technology, that only gives you a 0.5% improvement.

If the code spends 10% of its time bumping references up and down, something is wrong.

[Rusky]

Yes, Rust also makes it quite easy to minimize reference count bumps. Rc values are moved by default, which introduces no traffic, and increments are explicit calls to `clone`. You can have both optimizations together!

It's even possible to share an Rc-managed value across threads without switching to Arc, as long as the other thread(s) never needs to change the reference count and can be "scoped" (https://doc.rust-lang.org/stable/std/thread/fn.scope.html) to some lifetime that some particular Rc outlives.

[kazinator]

> Rc values are moved by default

That could similarly work for Arc values to minimize the atomic bumping.

[Rusky]

Yes, Arc values are also moved by default. I was referring to both.

[LegionMammal978]

It would be very odd for such a transformation to be so difficult that it would impose a roadblock; after all, I'd think it would usually be the application deciding it only has a single thread, rather than something 10 dependencies up the line.