Shared State Concurrency

Shared State Concurrency is concurrency among two or more processes (here, a process is a flow of control; rather than a particular type of kernel object) which have some shared state between them; which both processes can read to and write from. See also MessagePassingConcurrency.

SharedStateConcurrency has the following advantages...

Can be very fast.
Makes GlobalConsensus much easier to achieve
Makes passing around ReferenceObjects that much easier, especially if a pointer/reference valid in one process is valid in another.
Can be used to model MessagePassingConcurrency fairly easily.

...and disadvantages

Much more difficult to model and prove a system correct.
Requires lots of synchronization primitives (SynchronizationStrategies) to prevent race-conditions
Does not scale well to distributed systems, especially in the presence of unreliable connections between processes (i.e. over a network).

Criticisms of the "advantages" above:

It's not particularly useful for a system to be fast but incorrect, and in any case the speed advantage relative to message passing is small.
The point about GlobalConsensus is refuted at MessagePassingConcurrency. In a nutshell, this depends on the actual reliability of communications, not the concurrency model.
Passing ReferenceObjects is also easy in most message-passing models.
If you use MessagePassingConcurrency implemented in terms of shared state, then depending on how well the shared state is hidden:
- its disadvantages leak into the message passing layer, or
- its disadvantages don't leak, in which case it is an ImplementationDetail? and you should describe the system as using message passing.

CategoryConcurrency