[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-mnogopotochnost-napishite-minimalnyy-neblokiruyushchiy-arraylist-vsego-chetyre-metoda-add-get-remove-size":3},{"id":4,"slug":5,"topicId":6,"topicSlug":7,"topicName":8,"topicEmoji":9,"question":10,"answer":11,"codeLang":12,"codeSrc":12,"important":12,"commonMistakes":12,"modernUsage":12,"difficulty":13,"tags":14,"related":20,"progress":21,"seo":22},289,"napishite-minimalnyy-neblokiruyushchiy-arraylist-vsego-chetyre-metoda-add-get-remove-size",8,"mnogopotochnost","Многопоточность","🔀","Напишите минимальный неблокирующий ArrayList (всего четыре метода — add(), get(), remove(), size())","\u003C!-- grade: 4\u002F5 — реализация через copy-on-write; добавлено пояснение алгоритма -->\n\nРеализация потокобезопасного `ArrayList` без использования блокировок. Подход — **copy-on-write**: при каждой модификации создаётся новая копия внутреннего массива, а ссылка на массив обновляется атомарно через `volatile`.\n\n\u003Cdetails>\n\u003Csummary>Код: copy-on-write ArrayList\u003C\u002Fsummary>\n\n```java\nclass NonBlockingArrayList\u003CT> {\n    private volatile Object[] content = new Object[0];\n\n    NonBlockingArrayList\u003CT> add(T item) {\n        return add(content.length, item);\n    }\n\n    NonBlockingArrayList\u003CT> add(int index, T item) {\n        if (index \u003C 0) {\n            throw new IllegalArgumentException();\n        }\n        boolean needsModification = index > content.length - 1;\n        if (!needsModification) {\n            if (item == null) {\n                needsModification = content[index] != null;\n            } else {\n                needsModification = !item.equals(content[index]);\n            }\n        }\n        if (needsModification) {\n            final Object[] renewed = Arrays.copyOf(content, Math.max(content.length, index + 1));\n            renewed[index] = item;\n            content = renewed;\n        }\n        return this;\n    }\n\n    NonBlockingArrayList\u003CT> remove(int index) {\n        if (index \u003C 0 || index >= content.length) {\n            throw new IllegalArgumentException();\n        }\n        int size = content.length - 1;\n        final Object[] renewed = new Object[size];\n        System.arraycopy(content, 0, renewed, 0, index);\n        if (index + 1 \u003C size) {\n            System.arraycopy(content, index + 1, renewed, index, size - index);\n        }\n        content = renewed;\n        return this;\n    }\n\n    @SuppressWarnings(\"unchecked\")\n    T get(int index) {\n        return (T) content[index];\n    }\n\n    int size() {\n        return content.length;\n    }\n}\n```\n\n\u003C\u002Fdetails>\n\n**Принцип работы:**\n- **Чтение** (`get`, `size`) — доступ к `volatile`-ссылке, без блокировки и копирования. Очень дёшево.\n- **Запись** (`add`, `remove`) — создание нового массива, копирование элементов, обновление `volatile`-ссылки. Дорого при большом массиве.\n\n**Ограничения:**\n- Данная реализация **не является строго потокобезопасной** при конкурентных записях (два потока могут одновременно прочитать `content`, создать свои копии и последний перезапишет результат первого). Для полной потокобезопасности нужен CAS-цикл с `AtomicReference` или блокировка на запись, как в `CopyOnWriteArrayList` из JDK.\n- Аналог JDK — `java.util.concurrent.CopyOnWriteArrayList`, который использует `ReentrantLock` для защиты операций записи.\n\n> **На собеседовании** важно понимать trade-off: copy-on-write идеален для сценариев «много чтений, редкие записи» (списки подписчиков, кэши конфигурации), но плох для часто изменяемых списков.","","senior",[15,16,17,18,19],"потокобезопасность","copy-on-write","неблокирующий-ArrayList","volatile","concurrency",[],null,{"title":23,"description":24,"ogTitle":25,"ogDescription":26,"keywords":27,"schemaAnswer":33,"featuredSnippetReady":34},"Неблокирующий ArrayList в Java — add, get, remove, size — Gymterview","Реализация потокобезопасного ArrayList на volatile массиве с copy-on-write семантикой. Четыре метода: add(), get(), remove(), size().","Неблокирующий ArrayList в Java — volatile + copy-on-write","ArrayList на volatile массиве: каждая модификация создаёт новую копию массива. Чтение без блокировки, запись через Arrays.copyOf.",[28,29,30,31,32],"неблокирующий ArrayList Java","copy-on-write ArrayList","volatile массив","потокобезопасный список","CopyOnWrite","Неблокирующий ArrayList реализуется через volatile массив Object[]. При каждой модификации (add, remove) создаётся новая копия массива через Arrays.copyOf. Методы get() и size() работают без блокировки, так как volatile гарантирует видимость актуального состояния массива.",true]