Что такое консистентность?

Что такое консистентность

Консистентность — это одна из четырёх ключевых свойств транзакций (ACID), которая гарантирует, что база данных переходит из одного корректного состояния в другое корректное состояние. В контексте многопоточного программирования консистентность также означает согласованность данных между потоками.

Консистентность в контексте ACID (БД)

Консистентность (Consistency) гарантирует, что все бизнес-правила и ограничения целостности соблюдаются до и после выполнения транзакции.

Пример с нарушением консистентности

// Перевод денег между счётами
public class BankTransaction {
    public void transferMoney(Account from, Account to, double amount) {
        // Без гарантии консистентности могут произойти следующие сценарии:
        
        from.withdraw(amount);  // Деньги снимаются
        // ... если здесь произойдёт сбой ...
        to.deposit(amount);     // Деньги не поступят!
        
        // Нарушается консистентность: деньги исчезли из системы
    }
}

Правильная реализация с консистентностью

@Transactional  // ACID транзакция гарантирует консистентность
public void transferMoney(Account from, Account to, double amount) {
    // Либо обе операции выполняются успешно, либо ни одна
    from.withdraw(amount);
    to.deposit(amount);
    // БД гарантирует: если сбой — откат обеих операций (Rollback)
}

Ограничения целостности (Integrity Constraints)

Консистентность поддерживается через ограничения:

public class User {
    @Id
    @GeneratedValue
    private Long id;
    
    @NotNull        // Ограничение NOT NULL
    private String email;
    
    @Column(unique = true)  // Ограничение UNIQUE
    private String username;
    
    @Min(0)         // Ограничение значения
    @Max(150)
    private int age;
    
    @OneToMany      // Ограничение внешнего ключа
    private List<Post> posts;
}

БД не позволит нарушить эти правила, сохраняя консистентность.

Консистентность в многопоточности

В контексте Java многопоточности консистентность означает, что все потоки видят одно и то же состояние данных.

Проблема: отсутствие консистентности

public class SharedData {
    private int value = 0;
    
    public void increment() {
        value++;  // Не потокобезопасно
    }
    
    public int getValue() {
        return value;  // Может вернуть устаревшее значение
    }
}

Разные потоки видят разные значения — нарушена консистентность.

Решение: синхронизация

public class ConsistentData {
    private int value = 0;
    
    // Гарантирует видимость и атомарность
    public synchronized void increment() {
        value++;
    }
    
    public synchronized int getValue() {
        return value;
    }
}

Теперь все потоки видят одно и то же значение — консистентность достигнута.

Volatile для консистентности

public class Flag {
    private volatile boolean running = true;  // volatile гарантирует видимость
    
    public void stop() {
        running = false;  // Все потоки немедленно увидят изменение
    }
    
    public boolean isRunning() {
        return running;
    }
}

// Использование
Thread worker = new Thread(() -> {
    while (flag.isRunning()) {
        // ... работа ...
    }
});

Bez volatile один поток может не увидеть изменение другим потоком (проблема видимости памяти).

Консистентность в распределённых системах (BASE)

В современных системах различают:

Strong Consistency (Строгая консистентность)

// Сразу после записи все читают новое значение
user.setName("John");
assert user.getName().equals("John");  // Всегда true

Eventual Consistency (Итоговая консистентность)

// В масштабируемых системах консистентность наступает со временем
user.setName("John");  // Пишем в БД
Thread.sleep(1000);    // Ждём репликации
assert user.getName().equals("John");  // Теперь true

Примеры консистентности в реальных системах

1. Spring Data JPA

@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    @Transactional  // Гарантирует консистентность данных
    public void updateUser(User user) {
        user.setEmail("newemail@example.com");
        repository.save(user);
        // При сбое — откат, консистентность сохранена
    }
}

2. Cache Consistency

public class CachedData {
    private Map<String, String> cache = new ConcurrentHashMap<>();
    
    public void put(String key, String value) {
        cache.put(key, value);
    }
    
    public String get(String key) {
        return cache.get(key);  // Безопасно для многопоточности
    }
}

3. Database Constraints

-- Ограничение целостности
CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT NOT NULL,
    amount DECIMAL(10, 2) CHECK (amount > 0),  -- Консистентность: сумма положительная
    FOREIGN KEY (user_id) REFERENCES users(id)  -- Консистентность: пользователь существует
);

Инструменты для обеспечения консистентности

Проверка консистентности

public class ConsistencyTest {
    @Test
    public void testDataConsistency() throws InterruptedException {
        Counter counter = new Counter();
        
        // 10 потоков, каждый добавляет 1000
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            exec.submit(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            });
        }
        
        exec.shutdown();
        exec.awaitTermination(1, TimeUnit.SECONDS);
        
        // Если нет синхронизации: может быть < 10000
        // С синхронизацией: всегда ровно 10000
        assertEquals(10000, counter.getValue());
    }
}

Итоги

Консистентность — это свойство, гарантирующее, что:

1. В БД: данные соответствуют всем правилам целостности, транзакции атомарны
2. В многопоточности: все потоки видят актуальное состояние данных
3. В распределённых системах: данные согласованы (сейчас или в будущем)

Консистентность критична для корректности приложения и предотвращения потери или повреждения данных.