Что такое механизм COW?

COW (Copy-On-Write): оптимизация памяти

Что такое COW

Copy-On-Write это техника оптимизации памяти, где копия данных создаётся только когда её нужно модифицировать. До момента изменения оригинал и копия указывают на одно место в памяти.

Как работает

Шаг 1: Копируем данные
┌─────────┐
│ data[1] │ ← оригинал
└─────────┘
     ▲
     │ Оба указывают на один объект!
     │
┌─────────┐
│ copy[1] │ ← копия
└─────────┘

Шаг 2: Модифицируем копию
Обнаружили изменение → создаём НОВУЮ копию

┌─────────┐          ┌──────────┐
│ data[1] │          │ copy[1]' │ (новая)
└─────────┘          └──────────┘
Оригинал             Новая копия с изменениями
ось независимы!

Пример: JavaScript объекты

// Без COW (наивное копирование)
const obj1 = { name: 'John', age: 30 };
const obj2 = { ...obj1 }; // Копируем все свойства

obj2.name = 'Jane'; // Теперь есть две копии
// obj1 = { name: 'John', age: 30 }
// obj2 = { name: 'Jane', age: 30 }
// Потребовали памяти для двух объектов

// С COW (умное копирование)
const obj1 = { name: 'John', age: 30 };
const obj2 = obj1; // Не копируем, указываем на один объект
if (obj2 modified) {
  // ТОЛЬКО ТОГДА создаём копию
  const obj2_copy = { ...obj1 };
  obj2_copy.name = 'Jane';
}

Применение: Array slice

// Операция slice может быть оптимизирована COW
const array = [1, 2, 3, 4, 5]; // 1 MB памяти
const slice = array.slice(1, 3); // [2, 3]

// Наивная реализация: копирует все элементы
// Требует памяти пропорционально размеру

// С COW:
// slice просто указывает на те же данные
// Если slice модифицируем, тогда создаём новый массив

В операционных системах

// Fork() в Unix/Linux
// Создаёт новый процесс

const parent_memory = new ArrayBuffer(1000); // 1KB

const pid = fork(); // Создаём дочерний процесс

if (pid === 0) {
  // Дочерний процесс
  // С COW: память не копируется!
  // Указываем на ту же память
  
  // Когда пишем в память:
  parent_memory[0] = 99;
  // ТОЛЬКО ТОГДА создаётся копия для дочернего процесса
} else {
  // Родительский процесс
  // Его память не затронута
}

Пример: React мема

// React использует COW для оптимизации
const [state, setState] = useState({ user: { name: 'John' } });

// Наивное изменение
state.user.name = 'Jane'; // Плохо! мутируем оригинал

// Правильно (COW-подобное)
setState({
  ...state,
  user: {
    ...state.user,
    name: 'Jane'
  }
});
// Создаём новые объекты только где изменились данные

Структурное разделение (Structural Sharing)

Дерево данных:

Оригинал:          Изменение поля B:
┌───────┐          ┌───────┐
│ Root  │          │ Root' │ (новая)
└───────┘          └───────┘
   ├─A                 ├─A (указывает на старый!)
   └─B                 └─B' (новая)

70% памяти дерева переиспользуется!

Практический пример: Immutable.js

const Immutable = require('immutable');

// Обычный объект
const map1 = Immutable.Map({ a: 1, b: 2, c: 3 });
const map2 = map1.set('a', 10); // Вернёт новый Map

// Но внутри используется COW
// map1 и map2 шарят большинство данных
// Только изменённые части скопированы

console.log(map1.equals(map2)); // false
console.log(map1.get('a')); // 1
console.log(map2.get('a')); // 10

В git

# Git использует COW для хранения версий
git clone repo.git
# Не копирует весь репозиторий!
# Использует structure sharing
# Разные ветки указывают на одни файлы
# Только при изменении создаётся новая копия

Преимущества COW

✅ Экономия памяти (не копируем пока не нужно)
✅ Быстро (копирование O(1) вместо O(n))
✅ Логичное (данные кажутся immutable)
✅ Безопасно (исходные данные не меняются)

Недостатки

❌ Complexity (сложнее реализовать)
❌ Overhead (нужно отслеживать модификации)
❌ Не всегда помогает (частые изменения)

Когда использовать

✅ Large data structures
✅ Immutable programming
✅ Functional programming
✅ Когда памяти мало

❌ Частые изменения
❌ Простые маленькие объекты
❌ Когда нужна максимальная скорость

Заключение

COW это мощная техника оптимизации памяти:

• Не копируем данные пока не нужно
• Используется в ОС, БД, функциональных языках
• В JavaScript реализуется самостоятельно (spread оператор)
• Фундамент immutable структур данных