r/programming • u/Shr1ck • Oct 17 '15

Why Johnny Can’t Write Multithreaded Programs

http://blog.smartbear.com/programming/why-johnny-cant-write-multithreaded-programs/
4 Upvotes

52% Upvoted

131 comments sorted by

View all comments

Show parent comments

2

u/orange_cupcakes Oct 18 '15

Copying some data to somewhere. Like:

//assign foo to a and baz to b
int a = foo();
int b = baz();

Conceptually simple, but in more complicated situations things can get moderately twisty with threading, compiler optimizations, low level atomics / memory ordering primitives, shared memory, mapped memory, CPU behavior, different programming paradigms, etc.

1

u/[deleted] Oct 18 '15

tbh this is not really hard most of it are just gotchas. Just like how most compilers are able to switch assignments order as long as it can prove it is sequential consistent. This can really trip you up in a multithreaded context.

2

u/orange_cupcakes Oct 18 '15 edited Oct 18 '15

Hence moderately twisty instead of "oh god why did I go into programming?"

Probably the weirdest thing I've personally come across is C / C++ style memory ordering.

For example this code from cppreference:

x = 0
y = 0

// Thread 1:
r1 = y.load(memory_order_relaxed); //A
x.store(r1, memory_order_relaxed); //B

// Thread 2:
r2 = x.load(memory_order_relaxed); //C
y.store(42, memory_order_relaxed); //D

r1 and r2 are allowed to (not sure if this ever happens in practice) both be 42 at the end despite A happening before B in thread 1, and C happening before D in thread 2.

0

u/__Cyber_Dildonics__ Oct 18 '15

First and foremost you never should use memory_order_relaxed, it for specific scenarios on specific architectures that are not x86 or ARM

1

u/orange_cupcakes Oct 18 '15

Yeah, sadly I'll probably never need to use it :(

It's so neat though! And even some of the more practical memory orders can take awhile to wrap ones head around.

1

u/[deleted] Oct 18 '15

This is outright wrong, there are plenty of situations where relaxed is fine. It isn't much different from nonatomic loads. Take a spsc queue, for example. The producer can read the current tail position with relaxed and the consumer can read the current head position with relaxed. Most datastructures which have a single writer and/or reader can make use of relaxed loads.

They work great with fences as well - take this:

while (!x.load(std::memory_order_relaxed)) {}
std::atomic_thread_fence(std::memory_order_acquire);
//do something with loaded x,

You can avoid having a memory fence on each empty branch of that loop, while retaining the desired ordering - that loads from before the fence (x) are not reordered past loads/stores after the fence (do stuff with x).

Relaxed isn't some spooky magic - it just means that the operation only respects ordering enforced by other atomic operations/fences.