public class ApplicationConstants {
    // Конфигурационные параметры
    public static final List<String> SUPPORTED_LANGUAGES = 
        List.of("en", "es", "fr", "de");
    
    public static final Map<String, Integer> DEFAULT_SETTINGS = 
        Map.of("timeout", 30, "retries", 3, "cacheSize", 1000);
}

public List<String> getActiveUsers() {
    // Вместо возврата изменяемого списка
    return List.copyOf(internalUserList); // Защитная копия как неизменяемый список
}

public void processItems(List<String> items) {
    // items должен быть неизменяемым или защищенной копией
    List<String> safeItems = List.copyOf(items);
    // Далее работаем с safeItems
}

// НЕПРАВИЛЬНО: постоянное создание новых коллекций
List<String> items = List.of();
for (Item item : source) {
    items = Stream.concat(items.stream(), Stream.of(item.getName()))
                  .collect(Collectors.toUnmodifiableList()); // Очень дорого!
}

// ПРАВИЛЬНО: использование изменяемого построителя
List<String> itemsBuilder = new ArrayList<>();
for (Item item : source) {
    itemsBuilder.add(item.getName());
}
List<String> items = List.copyOf(itemsBuilder);

// Хорошо
List<String> good = List.of("A", "B", "C");

// Плохо (возвращает изменяемый список, но фиксированного размера)
List<String> bad = Arrays.asList("A", "B", "C");

public class SafeApi {
    private final List<String> data;
    
    public SafeApi(List<String> input) {
        // Защитное копирование в неизменяемый список
        this.data = List.copyOf(input);
    }
}

/**
 * Возвращает неизменяемый список активных пользователей.
 * Попытки модификации приведут к UnsupportedOperationException.
 */
public List<User> getActiveUsers() {
    return Collections.unmodifiableList(internalList);
}

// Хорошо: ясно указывает на намерение
public void processItems(List<? extends String> items) {
    // items может быть любым списком строк, включая неизменяемые
}

// Или даже лучше в Java 16+
public void processItems(SequencedCollection<String> items) {
    // Явное указание на коллекцию с определенным порядком
}

public static <T> List<T> loggingUnmodifiableList(List<T> list) {
    return new AbstractList<T>() {
        @Override
        public T get(int index) {
            return list.get(index);
        }
        
        @Override
        public int size() {
            return list.size();
        }
        
        @Override
        public void add(int index, T element) {
            logError("Attempt to modify unmodifiable list at index " + index);
            throw new UnsupportedOperationException();
        }
    };
}

// Мониторинг создания коллекций
public class CollectionMonitor {
    private static final AtomicLong listCreations = new AtomicLong();
    
    public static <E> List<E> monitoredListOf(E... elements) {
        listCreations.incrementAndGet();
        return List.of(elements);
    }
    
    public static long getCreationCount() {
        return listCreations.get();
    }
}

import java.util.*;

public class Task261225 {
    public static void main(String[] args) {
        Integer[] array = {1, 2, 3};
        List<Integer> list1 = Arrays.asList(array);
        List<Integer> list2 = List.of(array);
        List<Integer> list3 = Collections.unmodifiableList(list1);

        array[1] = 20;

        System.out.println(list2.get(1));
        System.out.println(list3.get(1));
    }
}

function scheduler_loop(queue, time_slice) {
    while (true) {
        process = queue.dequeue()
        reductions_executed = 0
        
        while (process.has_messages() && reductions_executed < time_slice) {
            message = process.next_message()
            result = process.execute(message)
            reductions_executed += calculate_reductions(result)
            
            if (process.crashed()) {
                notify_supervisor(process)
                break
            }
        }
        
        if (process.has_messages()) {
            queue.enqueue(process) // Вернуть в конец очереди
        }
    }
}

Frame Structure:
+----------+----------+----------+----------+----------+----------+
|   Type   | Channel  |   Size   |   Payload         | Frame End |
| (1 byte) | (2 bytes)| (4 bytes)| (size bytes)      | (1 byte)  |
+----------+----------+----------+----------+----------+----------+

Frame Types:
- METHOD (1)    : Вызов метода AMQP (declare, publish, consume)
- HEADER (2)    : Заголовки сообщения (properties, headers)
- BODY (3)      : Часть тела сообщения (может быть несколько фреймов)
- HEARTBEAT (8) : Keep-alive фрейм

[METHOD] Basic.Publish(exchange="amq.direct", routing_key="queue1")
[HEADER] properties={content_type: "text/plain"}, body_size=1024
[BODY]   chunk 1 of 1024 bytes
[BODY]   chunk 2 of 1024 bytes (если сообщение больше frame_max)

// Псевдокод обработки publish на стороне брокера
handle_publish(frame) {
    // 1. Парсинг и валидация фреймов
    method_frame = parse_method_frame(frame)
    header_frame = read_next_frame() // Ожидаем HEADER фрейм
    
    // 2. Поиск exchange по имени
    exchange = lookup_exchange(method_frame.exchange)
    if (!exchange) {
        if (method_frame.mandatory) {
            send_basic_return() // Сообщение возвращается отправителю
        }
        return
    }
    
    // 3. Маршрутизация через exchange
    routes = exchange.route(method_frame.routing_key, header_frame.properties)
    
    // 4. Для каждого получателя (очереди)
    for (queue in routes.queues) {
        // 5. Проверка TTL сообщения
        if (header_frame.properties.expiration && is_expired(header_frame)) {
            continue
        }
        
        // 6. Сохранение в очередь
        message = {
            id: generate_message_id(),
            properties: header_frame.properties,
            body: read_body_frames() // Чтение всех BODY фреймов
        }
        
        // 7. В зависимости от типа очереди
        if (queue.type == "quorum") {
            quorum_queue_append(queue, message)
        } else if (queue.type == "stream") {
            stream_append(queue, message)
        } else {
            classic_queue_append(queue, message)
        }
    }
    
    // 8. Подтверждение издателю (если включены publisher confirms)
    if (connection.publisher_confirms) {
        send_basic_ack(delivery_tag)
    }
}

Quorum Queue Architecture:
+-------------------+      +-------------------+      +-------------------+
|   Лидер           |      |   Последователь   |      |   Последователь   |
|   (Leader)        |<---->|   (Follower)      |<---->|   (Follower)      |
|                   |      |                   |      |                   |
| • Принимает запись|      | • Реплицирует     |      | • Реплицирует     |
| • Отвечает клиентам|      |   данные         |      |   данные          |
| • Управляет       |      | • Голосует за     |      | • Голосует за     |
|   логом Raft      |      |   выборы лидера   |      |   выборы лидера   |
+-------------------+      +-------------------+      +-------------------+
         |                         |                         |
         |       Кворум (N/2 + 1) узлов согласны            |
         +---------------------------------------------------+

// Псевдокод обработки записи в Quorum Queue
quorum_queue_append(queue, message) {
    // 1. Лидер добавляет запись в свой лог
    log_entry = {
        term: current_term,
        index: next_index++,
        command: "ADD_MESSAGE",
        data: message
    }
    
    leader_log.append(log_entry)
    
    // 2. Репликация на последователей
    followers_acked = 1 // Лидер уже записал
    
    for (follower in queue.followers) {
        send_append_entries(follower, log_entry)
        
        // 3. Ожидание подтверждения от большинства
        if (wait_for_ack(follower, timeout)) {
            followers_acked++
            
            if (followers_acked >= quorum_size(queue)) {
                // 4. Коммит записи (становится видимой для чтения)
                log_entry.committed = true
                apply_to_state_machine(queue, log_entry)
                return SUCCESS
            }
        }
    }
    
    // 5. Если кворум не достигнут
    if (followers_acked < quorum_size(queue)) {
        // Возврат к предыдущему индексу
        next_index--
        return FAILURE
    }
}

// Псевдокод работы Stream Queue
stream_append(queue, message) {
    // 1. Проверка дедупликации
    if (queue.deduplication_enabled && message.id in seen_ids) {
        return DUPLICATE
    }
    
    // 2. Добавление в текущий активный сегмент
    segment = get_active_segment(queue)
    
    // 3. Если сегмент заполнен, ротация
    if (segment.size + message.size > segment.max_size) {
        segment.close()
        segment = create_new_segment(queue)
        queue.active_segment = segment
        
        // 4. Компрессия закрытых сегментов (асинхронно)
        schedule_compression(closed_segments)
    }
    
    // 5. Запись в сегмент
    write_result = segment.append(
        offset: segment.next_offset++,
        timestamp: current_time(),
        message: message
    )
    
    // 6. Обновление индекса для быстрого поиска
    update_index(queue, message.id, segment.id, write_result.position)
    
    return write_result.offset
}

// Упрощенная схема работы журнала
wal_append(message) {
    // 1. Запись в журнал (последовательная запись)
    log_entry = serialize(message)
    wal_file.append(log_entry)
    fsync(wal_file) // Синхронизация с диском
    
    // 2. Добавление в in-memory структуры для быстрого доступа
    index_entry = {
        message_id: message.id,
        wal_position: current_position,
        queue: message.queue,
        status: "PERSISTED"
    }
    
    memory_index.add(index_entry)
    
    // 3. Периодическая очистка устаревших записей
    if (wal_file.size > max_wal_size) {
        rotate_wal_file()
    }
}

// Механизм flow control на основе памяти
check_memory_pressure() {
    memory_used = get_memory_usage()
    
    if (memory_used > memory_limit_high_watermark) {
        // 1. Приостановка публикаций
        block_publishers()
        
        // 2. Принудительная выгрузка сообщений на диск
        for (queue in queues) {
            if (queue.messages_in_memory > threshold) {
                page_to_disk(queue)
            }
        }
        
        // 3. Если не помогло, отключение соединений
        if (memory_used > memory_limit_critical) {
            disconnect_clients_by_memory_usage()
        }
    }
}