Как многопоточность влияет на иммутабельные объекты

# Как многопоточность влияет на иммутабельные объекты

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

Суть иммутабельности

Иммутабельный объект — это объект, который не может быть изменен после создания. Его состояние фиксировано:

public final class ImmutablePerson {
    private final String name;
    private final int age;
    
    public ImmutablePerson(String name, int age) {
        this.name = Objects.requireNonNull(name);
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

Ключ: final на полях и на самом классе, отсутствие setter'ов.

Преимущества в многопоточной среде

1. Нет гонок данных (Race Conditions)

public class MutablePerson {
    private int age;
    
    public synchronized void setAge(int newAge) {
        this.age = newAge;
    }
    
    public synchronized int getAge() {
        return age;
    }
}

public final class ImmutablePerson {
    private final int age;
    
    public ImmutablePerson(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return age;  // Синхронизация НЕ нужна!
    }
}

2. Visibility гарантирована

В Java есть правила visibility для многопоточности. Иммутабельные объекты решают эту проблему:

public class ImmutableHolder {
    private final ImmutablePerson person;
    
    public ImmutableHolder(ImmutablePerson p) {
        this.person = p;  // Гарантированно видна всем потокам
    }
    
    public ImmutablePerson getPerson() {
        return person;
    }
}

3. Отсутствие deadlock'ов

Блокировки создают deadlock'и. Иммутабельные объекты не требуют блокировок.

Как правильно реализовать иммутабельность

Правило 1: final на полях

public final class ImmutablePoint {
    private final int x;
    private final int y;
    
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

Правило 2: final на классе

public final class ImmutableList {
    private final List<String> items;
    
    public ImmutableList(List<String> items) {
        this.items = Collections.unmodifiableList(new ArrayList<>(items));
    }
}

Без final на классе кто-то может создать подкласс и сломать иммутабельность.

Правило 3: Защита от внешних изменений

public final class GoodImmutableList {
    private final List<String> items;
    
    public GoodImmutableList(List<String> items) {
        this.items = Collections.unmodifiableList(new ArrayList<>(items));
    }
    
    public List<String> getItems() {
        return items;
    }
}

Примеры из Java

String — идеальный пример

String — полностью иммутабельная, может использоваться в HashMap как ключ без проблем.

LocalDate — иммутабельная дата

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plusDays(1);  // Возвращает НОВЫЙ объект

ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
    executor.submit(() -> System.out.println(today));
}

Практический пример

public final class ImmutableUser {
    private final Long id;
    private final String email;
    private final List<String> roles;
    private final LocalDateTime createdAt;
    
    public ImmutableUser(Long id, String email, List<String> roles, LocalDateTime createdAt) {
        this.id = Objects.requireNonNull(id);
        this.email = Objects.requireNonNull(email);
        this.roles = Collections.unmodifiableList(new ArrayList<>(roles));
        this.createdAt = Objects.requireNonNull(createdAt);
    }
    
    public Long getId() { return id; }
    public String getEmail() { return email; }
    public List<String> getRoles() { return roles; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    
    public ImmutableUser withEmail(String newEmail) {
        return new ImmutableUser(id, newEmail, roles, createdAt);
    }
}

public class UserCache {
    private final Map<Long, ImmutableUser> cache = new ConcurrentHashMap<>();
    
    public void cacheUser(ImmutableUser user) {
        cache.put(user.getId(), user);
    }
    
    public ImmutableUser getUser(Long id) {
        return cache.get(id);
    }
}

Когда использовать иммутабельные объекты

1. Данные, которые не должны меняться: User, Config, Result
2. Объекты, передаваемые между потоками: Message, Event
3. Ключи в HashMap/HashSet: String, Integer
4. Кэшированные значения: всегда иммутабельные
5. Результаты операций: не меняйте после создания

Производительность

Практически нет штрафа:

• Создание нового объекта (копирование указателей) быстро
• Экономия на блокировках даёт больше производительности
• GC лучше справляется с иммутабельными объектами

Вывод

Иммутабельные объекты — один из лучших инструментов для безопасного многопоточного программирования. Они безопасны, просты, надёжны и быстры. Максимально используйте иммутабельность в Java приложениях.