Задачи и каналы — бесплатный тест онлайн

Вопрос 1 из 30

Какой механизм Julia определяет поведение строки `@task begin`?

Task: s_0\to s_1\to\cdots

function producer(n)
    @task begin
        s = 0
        for i in 1:n
            s += i
            iszero(i % 1000) && yield()
        end
        s
    end
end
t = producer(10_000)
schedule(t)
@show fetch(t)

Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния.

Вопрос 2 из 30

Какой тест точнее всего зафиксирует границу поведения `@task begin`?

function producer(n)
    @task begin
        s = 0
        for i in 1:n
            s += i
            iszero(i % 1000) && yield()
        end
        s
    end
end
t = producer(10_000)
schedule(t)
@show fetch(t)

Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Проверить на отдельном примере, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Проверить на отдельном примере, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Проверить на отдельном примере, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 3 из 30

Какой контракт следует закрепить при переработке строки `@task begin`?

function producer(n)
    @task begin
        s = 0
        for i in 1:n
            s += i
            iszero(i % 1000) && yield()
        end
        s
    end
end
t = producer(10_000)
schedule(t)
@show fetch(t)

Сохранить в реализации правило: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Сохранить в реализации правило: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Сохранить в реализации правило: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Сохранить в реализации правило: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 4 из 30

Как проверить, что новая реализация `@task begin` не изменила обещанное пользователю поведение?

Task: s_0\to s_1\to\cdots

Приёмка должна подтвердить, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Приёмка должна подтвердить, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Приёмка должна подтвердить, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Приёмка должна подтвердить, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 5 из 30

Как сформулировать границу механизма `@task begin` без чрезмерного обещания?

Указать в документации: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Указать в документации: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Указать в документации: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Указать в документации: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 6 из 30

Какое объяснение для `return Channel{Int}(capacity) do ch` выдержит проверку на другом допустимом входе?

0\le |Channel|\le capacity

function stream_values(n; capacity=2)
    return Channel{Int}(capacity) do ch
        for i in 1:n
            put!(ch, i^2)
        end
    end
end
@show collect(stream_values(5))

`Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Неограниченный Channel создаёт обратное давление, когда потребитель отстаёт, и тем самым ограничивает память. `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи.

Вопрос 7 из 30

Какую проверку стоит добавить для участка с `return Channel{Int}(capacity) do ch`?

function stream_values(n; capacity=2)
    return Channel{Int}(capacity) do ch
        for i in 1:n
            put!(ch, i^2)
        end
    end
end
@show collect(stream_values(5))

Проверить на отдельном примере, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Проверить на отдельном примере, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Проверить на отдельном примере, что неограниченный Channel создаёт обратное давление, когда потребитель отстаёт, и тем самым ограничивает память.

Вопрос 8 из 30

Какую гарантию должна сохранить правка участка с `return Channel{Int}(capacity) do ch`?

function stream_values(n; capacity=2)
    return Channel{Int}(capacity) do ch
        for i in 1:n
            put!(ch, i^2)
        end
    end
end
@show collect(stream_values(5))

Сохранить в реализации правило: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Сохранить в реализации правило: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Сохранить в реализации правило: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Сохранить в реализации правило: Неограниченный Channel создаёт обратное давление, когда потребитель отстаёт, и тем самым ограничивает память.

Вопрос 9 из 30

При переносе кода с `return Channel{Int}(capacity) do ch` в библиотеку какой критерий нельзя заменять впечатлением «пример работает»?

0\le |Channel|\le capacity

Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Приёмка должна подтвердить, что неограниченный Channel создаёт обратное давление, когда потребитель отстаёт, и тем самым ограничивает память. Приёмка должна подтвердить, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Приёмка должна подтвердить, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Приёмка должна подтвердить, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи.

Вопрос 10 из 30

Какое ограничение стоит прямо указать в документации к участку с `return Channel{Int}(capacity) do ch`?

Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Указать в документации: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Указать в документации: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Указать в документации: Неограниченный Channel создаёт обратное давление, когда потребитель отстаёт, и тем самым ограничивает память. Указать в документации: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи.

Вопрос 11 из 30

Какое утверждение точнее всего объясняет участок с `left = @async begin sleep(0.01); 20 end`?

T=\max_i T_i+T_{sync}

function load_pair()
    left = @async begin sleep(0.01); 20 end
    right = @async begin sleep(0.01); 22 end
    wait(left)
    wait(right)
    return fetch(left) + fetch(right)
end
@show load_pair()

Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Задачи, созданные через @async, выполняются в порядке создания, поэтому блокирующие участки и справедливость планирования можно отдельно не проверять. Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 12 из 30

Какую проверку стоит добавить для участка с `left = @async begin sleep(0.01); 20 end`?

function load_pair()
    left = @async begin sleep(0.01); 20 end
    right = @async begin sleep(0.01); 22 end
    wait(left)
    wait(right)
    return fetch(left) + fetch(right)
end
@show load_pair()

Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что задачи, созданные через @async, выполняются в порядке создания, поэтому блокирующие участки и справедливость планирования можно отдельно не проверять. Проверить на отдельном примере, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Проверить на отдельном примере, что ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Проверить на отдельном примере, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 13 из 30

Какое решение устраняет риск вокруг `left = @async begin sleep(0.01); 20 end`, не меняя поведение на допустимых данных?

function load_pair()
    left = @async begin sleep(0.01); 20 end
    right = @async begin sleep(0.01); 22 end
    wait(left)
    wait(right)
    return fetch(left) + fetch(right)
end
@show load_pair()

Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Сохранить в реализации правило: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Сохранить в реализации правило: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Сохранить в реализации правило: Задачи, созданные через @async, выполняются в порядке создания, поэтому блокирующие участки и справедливость планирования можно отдельно не проверять. Сохранить в реализации правило: Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии.

Вопрос 14 из 30

При переносе кода с `left = @async begin sleep(0.01); 20 end` в библиотеку какой критерий нельзя заменять впечатлением «пример работает»?

T=\max_i T_i+T_{sync}

Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Приёмка должна подтвердить, что ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Приёмка должна подтвердить, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Приёмка должна подтвердить, что задачи, созданные через @async, выполняются в порядке создания, поэтому блокирующие участки и справедливость планирования можно отдельно не проверять. Приёмка должна подтвердить, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 15 из 30

Что следует сообщить пользователю библиотеки о поведении `left = @async begin sleep(0.01); 20 end`?

Указать в документации: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Указать в документации: Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Указать в документации: Задачи, созданные через @async, выполняются в порядке создания, поэтому блокирующие участки и справедливость планирования можно отдельно не проверять. Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Указать в документации: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 16 из 30

Какое утверждение точнее всего объясняет участок с `fetch(t)`?

fetch(t)\uparrow e

function failing_task()
    @async begin
        sleep(0.01)
        error("worker failed")
    end
end
t = failing_task()
try
    fetch(t)
catch err
    @show typeof(err) err
end

Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Исключение из задачи всплывает в месте её создания, поэтому отдельный `wait` или `fetch` нужен лишь для получения результата. Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 17 из 30

Какую проверку стоит добавить для участка с `fetch(t)`?

function failing_task()
    @async begin
        sleep(0.01)
        error("worker failed")
    end
end
t = failing_task()
try
    fetch(t)
catch err
    @show typeof(err) err
end

Проверить на отдельном примере, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Проверить на отдельном примере, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Проверить на отдельном примере, что ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что исключение из задачи всплывает в месте её создания, поэтому отдельный `wait` или `fetch` нужен лишь для получения результата.

Вопрос 18 из 30

Какое требование к `fetch(t)` важнее удобной детали текущей реализации?

function failing_task()
    @async begin
        sleep(0.01)
        error("worker failed")
    end
end
t = failing_task()
try
    fetch(t)
catch err
    @show typeof(err) err
end

Сохранить в реализации правило: Исключение из задачи всплывает в месте её создания, поэтому отдельный `wait` или `fetch` нужен лишь для получения результата. Сохранить в реализации правило: Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Сохранить в реализации правило: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Сохранить в реализации правило: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой.

Вопрос 19 из 30

Две реализации участка с `fetch(t)` совпадают на обычных данных. Что необходимо проверить перед выпуском?

fetch(t)\uparrow e

Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Приёмка должна подтвердить, что исключение из задачи всплывает в месте её создания, поэтому отдельный `wait` или `fetch` нужен лишь для получения результата. Приёмка должна подтвердить, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Приёмка должна подтвердить, что ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Приёмка должна подтвердить, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой.

Вопрос 20 из 30

Какой тезис о `fetch(t)` можно честно закрепить в справке?

Указать в документации: Исключение из задачи всплывает в месте её создания, поэтому отдельный `wait` или `fetch` нужен лишь для получения результата. Указать в документации: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Указать в документации: Ошибка задачи становится видимой через `wait` или `fetch` и составные исключения; запись текста в журнал без завершения зависимых задач оставляет систему в неверном состоянии. Указать в документации: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 21 из 30

Как нужно интерпретировать `input = Channel{Int}(2)`, не добавляя к коду лишних гарантий?

P(complete)=1\;\text{при корректном закрытии}

function pipeline(values)
    input = Channel{Int}(2)
    output = Channel{Int}(2)
    @sync begin
        @async begin
            foreach(x -> put!(input, x), values)
            close(input)
        end
        @async begin
            for x in input
                put!(output, x^2)
            end
            close(output)
        end
    end
    return collect(output)
end
@show pipeline(1:5)

`Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Если конкурентный конвейер однажды выдал правильный итоговый список, его завершение, обратное давление и поведение при раннем закрытии уже подтверждены. Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи.

Вопрос 22 из 30

Какую проверку стоит добавить для участка с `input = Channel{Int}(2)`?

function pipeline(values)
    input = Channel{Int}(2)
    output = Channel{Int}(2)
    @sync begin
        @async begin
            foreach(x -> put!(input, x), values)
            close(input)
        end
        @async begin
            for x in input
                put!(output, x^2)
            end
            close(output)
        end
    end
    return collect(output)
end
@show pipeline(1:5)

Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Проверить на отдельном примере, что если конкурентный конвейер однажды выдал правильный итоговый список, его завершение, обратное давление и поведение при раннем закрытии уже подтверждены. Проверить на отдельном примере, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Проверить на отдельном примере, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния.

Вопрос 23 из 30

Какой контракт следует закрепить при переработке строки `input = Channel{Int}(2)`?

function pipeline(values)
    input = Channel{Int}(2)
    output = Channel{Int}(2)
    @sync begin
        @async begin
            foreach(x -> put!(input, x), values)
            close(input)
        end
        @async begin
            for x in input
                put!(output, x^2)
            end
            close(output)
        end
    end
    return collect(output)
end
@show pipeline(1:5)

Сохранить в реализации правило: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Сохранить в реализации правило: Если конкурентный конвейер однажды выдал правильный итоговый список, его завершение, обратное давление и поведение при раннем закрытии уже подтверждены. Сохранить в реализации правило: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Сохранить в реализации правило: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии.

Вопрос 24 из 30

Как проверить, что новая реализация `input = Channel{Int}(2)` не изменила обещанное пользователю поведение?

P(complete)=1\;\text{при корректном закрытии}

Приёмка должна подтвердить, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Приёмка должна подтвердить, что `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Приёмка должна подтвердить, что если конкурентный конвейер однажды выдал правильный итоговый список, его завершение, обратное давление и поведение при раннем закрытии уже подтверждены. Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Приёмка должна подтвердить, что созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи.

Вопрос 25 из 30

Какое утверждение о `input = Channel{Int}(2)` является переносимым правилом, а не особенностью одного запуска?

Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Указать в документации: Созданная через `@async` задача получает собственный системный поток, поэтому длинный вычислительный цикл не задерживает соседние задачи. Указать в документации: `Channel{T}` задаёт тип сообщений и может создавать обратное давление ограниченной ёмкостью; закрытие и исчерпание канала — разные состояния. Указать в документации: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Указать в документации: Если конкурентный конвейер однажды выдал правильный итоговый список, его завершение, обратное давление и поведение при раннем закрытии уже подтверждены.

Вопрос 26 из 30

Как нужно интерпретировать `stop = Ref(false)`, не добавляя к коду лишних гарантий?

cancel\Rightarrow close\Rightarrow cleanup

function supervised(jobs)
    stop = Ref(false)
    errors = Channel{Any}(length(jobs))
    tasks = [@async try
        stop[] || job()
    catch err
        stop[] = true
        put!(errors, (err, catch_backtrace()))
    end for job in jobs]
    foreach(wait, tasks)
    close(errors)
    return collect(errors)
end

Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Закрытие входного канала немедленно закрывает все выходные каналы и отменяет зависимые задачи без отдельного протокола. `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой.

Вопрос 27 из 30

Какой тест точнее всего зафиксирует границу поведения `stop = Ref(false)`?

function supervised(jobs)
    stop = Ref(false)
    errors = Channel{Any}(length(jobs))
    tasks = [@async try
        stop[] || job()
    catch err
        stop[] = true
        put!(errors, (err, catch_backtrace()))
    end for job in jobs]
    foreach(wait, tasks)
    close(errors)
    return collect(errors)
end

Проверить на отдельном примере, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Проверить на отдельном примере, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Проверить на отдельном примере, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Проверить на отдельном примере, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Проверить на отдельном примере, что закрытие входного канала немедленно закрывает все выходные каналы и отменяет зависимые задачи без отдельного протокола.

Вопрос 28 из 30

Какой контракт следует закрепить при переработке строки `stop = Ref(false)`?

function supervised(jobs)
    stop = Ref(false)
    errors = Channel{Any}(length(jobs))
    tasks = [@async try
        stop[] || job()
    catch err
        stop[] = true
        put!(errors, (err, catch_backtrace()))
    end for job in jobs]
    foreach(wait, tasks)
    close(errors)
    return collect(errors)
end

Сохранить в реализации правило: Закрытие входного канала немедленно закрывает все выходные каналы и отменяет зависимые задачи без отдельного протокола. Сохранить в реализации правило: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой. Сохранить в реализации правило: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Сохранить в реализации правило: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Сохранить в реализации правило: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс.

Вопрос 29 из 30

Как проверить, что новая реализация `stop = Ref(false)` не изменила обещанное пользователю поведение?

cancel\Rightarrow close\Rightarrow cleanup

Приёмка должна подтвердить, что устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Приёмка должна подтвердить, что `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Приёмка должна подтвердить, что корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Приёмка должна подтвердить, что закрытие входного канала немедленно закрывает все выходные каналы и отменяет зависимые задачи без отдельного протокола. Приёмка должна подтвердить, что планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой.

Вопрос 30 из 30

Что следует сообщить пользователю библиотеки о поведении `stop = Ref(false)`?

Указать в документации: `Task` выполняется кооперативно в рамках планировщика и переключается в точках ожидания; тяжёлый цикл без yield может задерживать другие задачи. Указать в документации: Устойчивость требует протокола отмены, закрытия каналов и идемпотентной очистки; принудительное завершение без координации может потерять сообщение или ресурс. Указать в документации: Корректность конкурентного конвейера проверяют на завершение, порядок там, где он обещан, обратное давление и отсутствие зависания при раннем закрытии. Указать в документации: Закрытие входного канала немедленно закрывает все выходные каналы и отменяет зависимые задачи без отдельного протокола. Указать в документации: Планирование через `@async`, `@sync`, `schedule`, `wait` и `fetch` определяет время ожидания и распространение ошибок; запущенная задача без владельца легко теряет сбой.