[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-mnogopotochnost-chem-otlichayutsya-dva-interfeysa-runnable-i-callable":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},256,"chem-otlichayutsya-dva-interfeysa-runnable-i-callable",8,"mnogopotochnost","Многопоточность","🔀","Чем отличаются два интерфейса Runnable и Callable?","\u003C!-- grade: 4\u002F5 — различия перечислены, но нет примера и контекста использования -->\n\nОба интерфейса предназначены для описания задач, выполняемых в отдельном потоке, но имеют существенные различия.\n\n### Сигнатуры\n\n```java\n\u002F\u002F Java 1.0\n@FunctionalInterface\npublic interface Runnable {\n    void run();\n}\n\n\u002F\u002F Java 5.0 (java.util.concurrent)\n@FunctionalInterface\npublic interface Callable\u003CV> {\n    V call() throws Exception;\n}\n```\n\n### Сравнение\n\n| Характеристика | `Runnable` | `Callable\u003CV>` |\n|---|---|---|\n| Появился в | Java 1.0 | Java 5.0 (`java.util.concurrent`) |\n| Метод | `run()` | `call()` |\n| Возвращаемое значение | `void` -- ничего не возвращает | `V` -- возвращает результат через `Future\u003CV>` |\n| Проверяемые исключения | Не может выбрасывать | Может выбрасывать `Exception` |\n| Использование с `Thread` | `new Thread(runnable)` | Нельзя напрямую -- только через `ExecutorService` |\n| Использование с `ExecutorService` | `execute(runnable)` или `submit(runnable)` | `submit(callable)` |\n\n### Примеры использования\n\n\u003Cdetails>\n\u003Csummary>Пример: Runnable vs Callable\u003C\u002Fsummary>\n\n```java\npublic class RunnableVsCallable {\n    public static void main(String[] args) throws Exception {\n        ExecutorService executor = Executors.newSingleThreadExecutor();\n\n        \u002F\u002F Runnable: нет возвращаемого значения, нет checked exceptions\n        Runnable task1 = () -> {\n            System.out.println(\"Runnable выполняется\");\n            \u002F\u002F return \"результат\"; \u002F\u002F Ошибка компиляции!\n            \u002F\u002F throw new IOException(); \u002F\u002F Ошибка компиляции!\n        };\n        Future\u003C?> future1 = executor.submit(task1);\n        future1.get(); \u002F\u002F null (Runnable ничего не возвращает)\n\n        \u002F\u002F Callable: возвращает значение и может бросать checked exceptions\n        Callable\u003CString> task2 = () -> {\n            if (someCondition()) {\n                throw new IOException(\"Ошибка ввода-вывода\");\n            }\n            return \"Результат вычисления\";\n        };\n        Future\u003CString> future2 = executor.submit(task2);\n        String result = future2.get(); \u002F\u002F \"Результат вычисления\"\n\n        executor.shutdown();\n    }\n}\n```\n\n\u003C\u002Fdetails>\n\n### Когда что использовать\n\n- **`Runnable`** -- когда задача не возвращает результат и не нужно пробрасывать проверяемые исключения. Также используется при создании потоков через `new Thread(runnable)`.\n- **`Callable`** -- когда нужен результат выполнения задачи или задача может выбросить проверяемое исключение. Всегда используется с `ExecutorService`.\n\n### Конвертация Runnable в Callable\n\nУтилитный метод `Executors.callable(Runnable task, T result)` позволяет обернуть `Runnable` в `Callable`:\n\n```java\nCallable\u003CString> wrapped = Executors.callable(runnable, \"default\");\n```\n\n> **Аналогия из жизни.** `Runnable` -- это записка «Сходи в магазин», на которой нет места для ответа. `Callable` -- это записка «Сходи в магазин и принеси чек», к которой приложен конверт для ответа (`Future`). Кроме того, `Callable` позволяет написать «если магазин закрыт -- сообщи» (checked exception), а `Runnable` -- нет.\n\n> **На собеседовании.** Четыре ключевых отличия: (1) `Callable` возвращает результат через `Future`, (2) `Callable` может бросать checked exceptions, (3) `Callable` появился в Java 5 вместе с `java.util.concurrent`, (4) `Callable` нельзя передать в конструктор `Thread` напрямую. Бонусный ответ: оба интерфейса являются `@FunctionalInterface` и могут быть заданы лямбда-выражением.","","junior",[15,16,17,18,19],"Runnable","Future","Callable","интерфейс","concurrency",[],null,{"title":23,"description":24,"ogTitle":25,"ogDescription":26,"keywords":27,"schemaAnswer":32,"featuredSnippetReady":33},"Runnable vs Callable в Java — 4 отличия — Gymterview","Callable появился в Java 5, возвращает Future с результатом и может выбрасывать checked-исключения. Runnable — void run() без исключений.","Runnable vs Callable — 4 ключевых отличия","Runnable.run() — void, без checked-исключений. Callable.call() — возвращает Future, может бросать checked-исключения. Callable — с Java 5.",[28,29,30,31],"Runnable vs Callable Java","Callable Java","Runnable Callable разница","Future Callable","Runnable (Java 1.0) определяет метод run() без возвращаемого значения и без checked-исключений. Callable (Java 5) определяет метод call(), который возвращает объект Future с результатом и может выбрасывать проверяемые исключения.",true]