Consistency models

1️⃣ Как кратко ответить

Consistency models определяют, как и когда обновления данных, сделанные в одной части распределенной системы, становятся видимыми в других частях системы. Они варьируются от строгих, таких как Strong Consistency, где все узлы видят обновления одновременно, до более слабых, таких как Eventual Consistency, где узлы могут видеть обновления с задержкой.

2️⃣ Подробное объяснение темы

Consistency models — это концепции, которые описывают, как данные в распределенной системе синхронизируются между различными узлами. Они определяют, как и когда изменения, сделанные в одной части системы, становятся видимыми в других частях. Это важно для обеспечения согласованности данных и правильной работы приложений, использующих распределенные системы.

Зачем нужны consistency models?

В распределенных системах данные могут храниться на множестве узлов, которые могут находиться в разных географических локациях. Когда данные обновляются на одном узле, необходимо решить, как и когда эти изменения будут видны на других узлах. Consistency models помогают определить баланс между доступностью, производительностью и согласованностью данных.

Основные модели согласованности

1. Strong Consistency (Сильная согласованность):

   • Все узлы видят обновления одновременно.
   • Гарантирует, что после выполнения операции записи все последующие операции чтения будут видеть это обновление.
   • Пример: Системы, требующие строгой согласованности, такие как банковские приложения.

2. Eventual Consistency (Конечная согласованность):

   • Обновления в конечном итоге становятся видимыми на всех узлах, но с возможной задержкой.
   • Подходит для систем, где допустимы временные несоответствия, например, в социальных сетях.
   • Пример: DNS-серверы, где изменения могут занять время для распространения.

3. Causal Consistency (Причинно-следственная согласованность):

   • Обеспечивает, что операции, которые зависят друг от друга, видны в правильном порядке.
   • Если операция A влияет на операцию B, то все узлы увидят A перед B.
   • Пример: Системы обмена сообщениями, где порядок сообщений важен.

4. Read-Your-Writes Consistency (Согласованность чтения своих записей):

   • Гарантирует, что после записи данных, последующие чтения от того же клиента будут видеть это обновление.
   • Полезно для пользовательских интерфейсов, где пользователь ожидает видеть свои изменения сразу.

5. Monotonic Read Consistency (Монотонная согласованность чтения):

   • Гарантирует, что если клиент прочитал значение, то все последующие чтения будут видеть это значение или более новое.
   • Пример: Системы, где важно видеть только возрастающие версии данных.

Пример кода

Рассмотрим пример, иллюстрирующий Eventual Consistency:

package main
​
import (
	"fmt"
	"sync"
	"time"
)
​
// Симуляция узла в распределенной системе
type Node struct {
	data string
	mu   sync.Mutex
}
​
// Обновление данных на узле
func (n *Node) updateData(newData string) {
	n.mu.Lock()
	defer n.mu.Unlock()
	n.data = newData
}
​
// Чтение данных с узла
func (n *Node) readData() string {
	n.mu.Lock()
	defer n.mu.Unlock()
	return n.data
}
​
// Симуляция распространения обновлений между узлами
func propagateUpdates(nodes []*Node, newData string) {
	for _, node := range nodes {
		go func(n *Node) {
			time.Sleep(time.Second) // Симуляция задержки
			n.updateData(newData)
		}(node)
	}
}
​
func main() {
	// Создаем три узла
	node1 := &Node{data: "initial"}
	node2 := &Node{data: "initial"}
	node3 := &Node{data: "initial"}
​
	nodes := []*Node{node1, node2, node3}
​
	// Обновляем данные на первом узле
	node1.updateData("updated")
​
	// Распространяем обновления на другие узлы
	propagateUpdates(nodes, "updated")
​
	// Чтение данных с каждого узла
	for i, node := range nodes {
		fmt.Printf("Node %d data: %s\n", i+1, node.readData())
	}
}

• Node: Структура, представляющая узел в распределенной системе. Содержит данные и мьютекс для синхронизации доступа.
• updateData: Метод для обновления данных на узле. Использует мьютекс для обеспечения безопасного доступа.
• readData: Метод для чтения данных с узла. Также использует мьютекс.
• propagateUpdates: Функция, которая симулирует распространение обновлений между узлами с задержкой.
• main: Создает три узла, обновляет данные на одном из них и распространяет обновления на другие узлы. Затем читает и выводит данные с каждого узла.

Этот пример демонстрирует, как данные могут быть обновлены на одном узле и с задержкой распространены на другие, что характерно для модели конечной согласованности.