Deprecate synchronized classes please!

[IGotD-]

On Tuesday, 6 September 2022 at 09:09:49 UTC, Loara wrote:
>
> Now it seems that D is moving from `synchronized` approach 
> (that brings a lot of deadlocks threats) to a `shared` approach 
> (passing only references to integer variables and access them 
> only with atomic operations). Maybe we should finally deprecate 
> `synchronized` class and leave only `synchronized` functions 
> inside `@system` code since they can't be safe due to deadlock 
> risks?

No, the fundamental principle of shared and synchronized is 
different. With synchronized classes the compiler automatically 
inserts mutex calls in order to ensure no data races. This is 
really good as you don't need to worry forgetting about not 
acquiring/releasing a mutex. Shared is a bit different that 
currently rely on atomic operations but this approach is flawed 
in my opinion. Shared should be "do anything you want, you are on 
your own".

The reason is that you cannot always rely on atomic operations is 
because they are very difficult, no compiler can ensure it and it 
is often not even possible. Therefore mutex are often used and 
therefore synchronized has its place and should be the most 
common way to share data structures.

The golden rule of shared memory is, take the lock. This means 
you are often wasting your time with atomic operations also 
suddenly when you have several atomic variables you open up for 
data races again. Atomic operation often only works when there is 
one variable, when there are several you often must take the 
lock. Several atomic variables are often mind twisting difficult 
in order to get it right.

Something that I miss in D is the "user space spinlock", which in 
Windows are EnterCriticalSection/LeaveCriticalSection and on 
Linux the futex. These are not pure spinlocks but the fastest you 
have that are safe. Pure spinlocks are not recommended for user 
programs. We need a cross platform interface for these. For 
faster lock times use these.

Take the lock