WikiGalaxy

Personalize

Consistency Models in Distributed Systems

Introduction

Consistency models are crucial in distributed systems to ensure that all nodes have a consistent view of data. Understanding these models is essential for designing systems that meet specific requirements for data consistency, availability, and partition tolerance.

Strong Consistency

Strong consistency ensures that any read operation returns the most recent write for a given piece of data. This model is often implemented using techniques like two-phase commit or Paxos.

Eventual Consistency

In eventual consistency, updates will propagate to all nodes, but it does not guarantee immediate visibility. This model is suitable for systems where availability is prioritized over immediate consistency.

Causal Consistency

Causal consistency ensures that operations that are causally related are seen by all nodes in the same order. This model is less strict than strong consistency but more predictable than eventual consistency.

Read Your Writes Consistency

This model ensures that a user can immediately see the results of their own writes. It is useful in systems where user experience is crucial, such as social media platforms.

Monotonic Reads Consistency

Monotonic reads guarantee that if a process has seen a particular value for a data item, it will never see an older value. This model helps in maintaining a consistent user experience across sessions.

Example: Strong Consistency


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
public class StrongConsistencyExample {
    public static void main(String[] args) {
        SpringApplication.run(StrongConsistencyExample.class, args);
    }
}

@RestController
@RequestMapping("/data")
class DataController {
    private String data = "Initial Data";

    @GetMapping
    public String getData() {
        return data;
    }

    @PostMapping
    public void updateData(@RequestBody String newData) {
        data = newData;
    }
}

Explanation

This Spring Boot application demonstrates strong consistency by ensuring that any read operation returns the most recent write. The data is updated immediately upon receiving a POST request, and subsequent GET requests will reflect this change.

Example: Eventual Consistency


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.ConcurrentHashMap;

@SpringBootApplication
public class EventualConsistencyExample {
    public static void main(String[] args) {
        SpringApplication.run(EventualConsistencyExample.class, args);
    }
}

@RestController
@RequestMapping("/eventual")
class EventualController {
    private ConcurrentHashMap<String, String> dataStore = new ConcurrentHashMap<>();

    @GetMapping("/{key}")
    public String getData(@PathVariable String key) {
        return dataStore.getOrDefault(key, "No Data");
    }

    @PostMapping("/{key}")
    public void updateData(@PathVariable String key, @RequestBody String value) {
        dataStore.put(key, value);
    }
}

Explanation

This example illustrates eventual consistency using a concurrent hash map to store data. Updates are made asynchronously, and the system guarantees that all nodes will eventually reflect the changes.

Example: Causal Consistency


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.ConcurrentHashMap;

@SpringBootApplication
public class CausalConsistencyExample {
    public static void main(String[] args) {
        SpringApplication.run(CausalConsistencyExample.class, args);
    }
}

@RestController
@RequestMapping("/causal")
class CausalController {
    private ConcurrentHashMap<String, String> dataStore = new ConcurrentHashMap<>();
    private ConcurrentHashMap<String, Long> versionStore = new ConcurrentHashMap<>();

    @GetMapping("/{key}")
    public String getData(@PathVariable String key) {
        return dataStore.getOrDefault(key, "No Data");
    }

    @PostMapping("/{key}")
    public void updateData(@PathVariable String key, @RequestBody String value) {
        dataStore.put(key, value);
        versionStore.put(key, System.currentTimeMillis());
    }
}

Explanation

This example maintains causal consistency by associating each data item with a version timestamp. Updates are applied only if they respect the causal order, ensuring that causally related operations are seen in the correct order.

Example: Read Your Writes Consistency


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.ConcurrentHashMap;

@SpringBootApplication
public class ReadYourWritesExample {
    public static void main(String[] args) {
        SpringApplication.run(ReadYourWritesExample.class, args);
    }
}

@RestController
@RequestMapping("/readwrites")
class ReadWritesController {
    private ConcurrentHashMap<String, String> dataStore = new ConcurrentHashMap<>();

    @GetMapping("/{key}")
    public String getData(@PathVariable String key) {
        return dataStore.getOrDefault(key, "No Data");
    }

    @PostMapping("/{key}")
    public void updateData(@PathVariable String key, @RequestBody String value) {
        dataStore.put(key, value);
    }
}

Explanation

This example implements read your writes consistency by ensuring that after a write, subsequent reads from the same client will return the written value. This is achieved by storing data in a concurrent hash map.

Example: Monotonic Reads Consistency


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.ConcurrentHashMap;

@SpringBootApplication
public class MonotonicReadsExample {
    public static void main(String[] args) {
        SpringApplication.run(MonotonicReadsExample.class, args);
    }
}

@RestController
@RequestMapping("/monotonic")
class MonotonicController {
    private ConcurrentHashMap<String, String> dataStore = new ConcurrentHashMap<>();
    private ConcurrentHashMap<String, Long> lastReadVersion = new ConcurrentHashMap<>();

    @GetMapping("/{key}")
    public String getData(@PathVariable String key) {
        Long lastVersion = lastReadVersion.getOrDefault(key, 0L);
        String data = dataStore.getOrDefault(key, "No Data");
        if (dataStore.containsKey(key) && lastVersion < System.currentTimeMillis()) {
            lastReadVersion.put(key, System.currentTimeMillis());
            return data;
        }
        return "Data Not Available";
    }

    @PostMapping("/{key}")
    public void updateData(@PathVariable String key, @RequestBody String value) {
        dataStore.put(key, value);
    }
}

Explanation

This example demonstrates monotonic reads consistency by ensuring that once a client has read a version of a data item, it will not see an older version in subsequent reads. This is managed by tracking the version of the last read data.