Java for Beginner

Многопоточность в Java: volatile и Immutable Classes

Volatile

Ключевое слово volatile в Java используется для обозначения переменных, которые могут быть изменены различными потоками. Переменная, объявленная как volatile, гарантирует, что все потоки будут читать ее актуальное значение из основной памяти, а не из кэша процессора. Это помогает избежать некоторых проблем с видимостью, которые могут возникнуть в многопоточных приложениях.

Пример использования volatile

public class VolatileExample {
    private volatile boolean running = true;

    public void start() {
        new Thread(() -> {
            while (running) {
                System.out.println("Thread is running...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread stopped.");
        }).start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        example.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.stop();
    }
}

В этом примере поток проверяет значение переменной running и останавливается, когда она становится false. Использование volatile гарантирует, что изменения переменной running будут видны всем потокам.

Immutable Classes

Иммутабельные (неизменяемые) классы — это классы, состояния объектов которых не могут быть изменены после создания. Они особенно полезны в многопоточной среде, так как обеспечивают безопасность потоков (thread-safety) без необходимости использования синхронизации.

Пример неизменяемого класса

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    
    @Override
    public String toString() {
        return "ImmutablePerson{name='" + name + "', age=" + age + "}";
    }
    
    public static void main(String[] args) {
        ImmutablePerson person = new ImmutablePerson("John", 30);
        System.out.println(person);
        // person.setName("Doe"); // This would cause a compile error
    }
}

В этом примере класс ImmutablePerson является неизменяемым, потому что все его поля final, и они инициализируются только один раз в конструкторе.

Преимущества неизменяемых классов

Потокобезопасность: Нет необходимости в синхронизации, так как состояние объекта не может быть изменено после создания.
Простота использования: Меньше ошибок, связанных с изменением состояния.
Упрощенная разработка: Легче проектировать и отлаживать.

#Java #Training #Multithreading #Medium #Volatile #Immutable_Classes

139 viewsДен, edited 05:48

Java for Beginner

@Immutable в Hibernate

Аннотация @Immutable помечает сущность или коллекцию как неизменяемую, что означает, что Hibernate игнорирует любые попытки обновления или удаления таких объектов. Это полезно для оптимизации производительности и предотвращения случайных изменений.
Пакет: org.hibernate.annotations.

1. Применение и параметры

@Immutable не имеет параметров — это маркерная аннотация.

Где может применяться:
На уровне класса (сущности):

@Entity  
@Immutable  
public class LogEntry { ... }  
Все экземпляры LogEntry становятся read-only.

На уровне коллекции:

@OneToMany  
@Immutable  
private List<LogEntry> logs; // Элементы коллекции нельзя изменить

2. Жизненный цикл и поведение

При загрузке:
Объекты загружаются как обычно, но Hibernate не отслеживает изменения (не добавляет их в PersistenceContext для dirty-checking).

При попытке обновления:
Выбрасывается исключение UnsupportedOperationException (если попытаться изменить поле или вызвать entityManager.merge()).

При удалении:
Игнорируется (если только не используется @SQLDelete с кастомным запросом).

Кэширование:
Сущности с @Immutable идеально подходят для кэширования (например, @Cacheable), так как никогда не меняются.

Механизмы Hibernate и Spring Boot

1. Как Hibernate обрабатывает @Immutable

Оптимизации:
Пропускает dirty-checking для таких сущностей, что ускоряет flush().
Не создает прокси для ленивых загрузок (если @Immutable применен к коллекции).

Исключения:
Session.update(), Session.merge(), Session.delete() игнорируются или выбрасывают исключение.

2. Интеграция с JPA и Spring Boot

JPA-аналоги:

Стандарт JPA не имеет прямой замены @Immutable, но можно эмулировать через:

@Entity  
@DynamicUpdate(false) // Отключает генерацию UPDATE  
@org.hibernate.annotations.OptimisticLocking(type = NONE) // Отключает версионирование  
public class LogEntry { ... }

Примеры использования

1. Справочные данные (Countries, Currencies)

@Entity  
@Immutable  
public class Currency {  
    @Id  
    private String code; // USD, EUR  
    private String name;  
    // Нет сеттеров  
}

Запросы только на чтение:

List<Currency> currencies = entityManager  
    .createQuery("SELECT c FROM Currency c", Currency.class)  
    .getResultList();

2. Логи и аудит (неизменяемые записи)

@Entity  
@Immutable  
public class AuditLog {  
    @Id @GeneratedValue  
    private Long id;  
    private String action;  
    @Column(updatable = false)  
    private LocalDateTime createdAt;  
}

3. Неизменяемые коллекции

@Entity  
public class User {  
    @Id private Long id;  
    @OneToMany  
    @Immutable  
    private List<LoginHistory> history; // История логинов только для чтения  
}

Ограничения и обходные пути

1. Что нельзя сделать с @Immutable
Обновлять поля: Даже через нативный SQL (entityManager.createNativeQuery("UPDATE...")), если только не отключить проверки Hibernate.
Каскадные операции: CascadeType.PERSIST работает, но MERGE, DELETE — нет.

2. Альтернативы

Read-only транзакции (Spring):

@Transactional(readOnly = true) // Оптимизация на уровне JDBC  
public List<Currency> getCurrencies() { ... }

DTO и проекции:

public interface CurrencyView {  
    String getCode();  
    String getName();  
}  
Плюс: не требуют Hibernate-сущностей.

#Java #Training #Hard #Spring #Hibernate #Immutable

134 views05:59

About

Blog

Apps

Platform