In computer science, consistency models are used in distributed
systems like distributed shared memory systems or distributed data stores (such as
a filesystems, databases, optimistic
replication systems or Web caching). The system supports a given model if operations on memory
follow specific rules. The data consistency model specifies a contract between programmer and system, wherein the system guarantees that if the programmer follows the rules, memory will be consistent and
the results of memory operations will be predictable.
High level languages, such as C, C++, and Java, partially maintain the contract by translating memory operations into low-level operations in a way that preserves memory
semantics. To hold to the contract, compilers may reorder some memory instructions, and library calls such as pthread_mutex_lock() encapsulate
required synchronization.[1]
Verifying sequential consistency is undecidable in
general, even for finite-state cache-coherence protocols.[2]
Consistency models define rules for the apparent order and visibility of updates, and it is a continuum with
tradeoffs.[3]
Contents
[hide]
Example[edit]
Assume that the following case occurs:[3]
- The row X is replicated on nodes M and N
- The client A writes row X to node N
- After a period of time t, client B reads row X from node M
The consistency model has to determine whether client B sees the write from client A or not.
Types[edit]
A non-exhaustive list of consistency models are
- causal consistency
- delta consistency
- entry
consistency - eventual consistency
- fork consistency
- linearizability (also known as strict or atomic consistency)
- one-copy
serializability - PRAM consistency (also known as FIFO consistency)
- release consistency
- sequential consistency
- serializability
- vector-field consistency
- weak consistency
- strong consistency