Ответы на вопросы из коллекции "Параллельное программирование с помощью языка C#"

Для отмены задачи необходимо

• вызвать метод Cancel для объекта типа Task
• вызвать метод Cancel для объекта типа CancellationTokenSource
• вызвать метод Cancel для объекта типа CancellationToken
• вызвать метод Abort для объекта типа Task

Какой фрагмент кода гарантирует запуск метода f1 до запуска метода f2.

• Task t1 = new Task(f1); t1.Start(); f2();
• Task t1 = Task.Factory.StartNew(f1); f2();
• Task t1 = new Task(f1); t1.Start(); Thread.Sleep(500); f2();
• ни один из предложенных вариантов

Освобождение или захват семафора приводит к исключению в следующих случаях

• при освобождении семафора значение внутреннего счетчика превысило заданное максимальное значение
• при захвате семафора значение внутреннего счетчика превысило заданное максимальное значение
• при захвате семафора значение внутреннего счетчика стало меньше заданного минимального значения
• освобождение и захват семафоров не приводит к исключениям

В родительской задаче tParent запускаются поочередно вложенные задачи tChild1 и tChild2. При каких условиях вложенная задача tChild1 может успеть завершиться раньше, чем задача tChild2?

• задача tChild2 является менее вычислительно емкой, чем tChild1 (меньшее время выполнения)
• задача tChild2 создана с опцией PreferFairness.
• свободный рабочий поток заимствует задачу tChild2 из локальной очереди
• задача tChild1 ожидает завершения задачи tChild2 с помощью оператора Wait.

Следующий фрагмент кода приводит к действиям планировщика: static void Main() { .. Task t1 = Task.Factory.StartNew( () => SomeWork()); Task t2 = Task.Factory.StartNew( () => SoweWork()); .. }

• задачи t1 и t2 помещаются в глобальную очередь пула потоков
• задачи t1 и t2 помещаются в одну и ту же локальную очередь рабочего потока
• задачи t1 и t2 помещаются в локальные очереди разных рабочих потоков
• ни один из перечисленных вариантов

При выполнении параллельной обработки с помощью метода Parallel.Invoke

• число потоков может динамически изменяться
• число потоков задается в качестве аргумента метода Parallel.Invoke
• число потоков может динамически изменяться, но не больше числа ядер вычислительной системы
• число потоков зависит от количества итераций и определяется на этапе инициализации обработки

Операторы агрегирования для объекта ParallelQuery

• выполняется параллельно
• выполняется последовательно
• могут выполняться как последовательно, так и параллельно
• объект ParallelQuery не позволяет выполнять операторы агрегирования

Какие операторы используются только в параллельных запросах

• AsUnordered
• SelectMany
• Aggregate
• WithCancellation

Сигнальные сообщения типа ManualResetEvent позволяют:

• реализовать взаимно-исключительный доступ к фрагменту кода
• реализовать доступ заданного числа потоков к фрагменту кода
• реализовать одновременный запуск всех заблокированных потоков
• реализовать запуск только одного из ожидающих потоков

Статус задачи WaitingForActivation соответствует ситуации:

• задача дожидается завершения предшествующих задач
• задача дожидается завершения вложенных задач
• задача добавлена в очередь пула потоков и готова к выполнению
• задача объявлена, но было вызова метода Start

Для обработки исключений, возникающих в задаче, блок try обрамляет:

• вызов метода ожидания задачи t.Wait()
• вызов метода запуска задачи t.Start()
• объявление задачи Task t = new Task(..);
• нет правильных вариантов

Свободный рабочий поток

• обращается к глобальной очереди, если она пуста – обращается к локальной очереди занятого рабочего потока
• просматривает локальные очереди рабочих потоков, если они пусты – обращается к глобальной очереди
• уничтожается планировщиком
• переходит в спящее состояние

При осуществлении пакетной обработки с помощью метода Parallel.ForEach делегат обработки вызывается

• на этапе инициализации
• на этапе выполнения обработки для каждого элемента
• только один раз для каждого потока на этапе выполнения обработки
• на этапе финальной редукции

Стратегия Inlined Execution применяется планировщиком

• для запуска задач из локальной очереди потока, если текущая задача заблокирована вызовом ожидания
• для запуска задач из глобальной очереди, если текущая задача заблокирована
• для заимствования задач свободным потоком из очереди занятого потока
• для запуска задачи в независимом потоке

При осуществлении агрегированных вычислений с помощью метода Parallel.For синхронизация необходима

• на этапе инициализации
• на этапе выполнения обработки
• на этапе финальной редукции
• синхронизация не требуется

Какой метод объекта ParallelLoopState позволяет досрочно выйти из цикла, но обработать все итерации с номером меньшим, чем заданный?

• Abort
• Break
• Stop
• не существует метода для досрочного выхода из параллельного цикла

Какие методы работают без явного объявления задач:

• Parallel.Invoke;
• Task.Factory.StartNew
• ThreadPool.QueueUserWorkItem;
• Parallel.ForEach

Разделение данных по диапазону осуществляется в следующих PLINQ-запросах:

• разделение данных по диапазону осуществляется во всех PLINQ-запросах
• >var q = Partitioner.Create(ParallelData, true) Where(item=>f(item)).Select(item=>f(item);
• var q = ParallelEnumerable.Range(1, 1000).Where(i => i%5 == 0).Select(i=> i*i);
• var q = ParallelData.GroupBy(o.Key);

Операция извлечения Take для объекта типа BlockedCollection, не содержащего элементы и без вызова CompleteAdding, приводит

• блокировка текущего потока
• метод возвращает null
• генерируется исключение
• метод возвращает false

Параметр LongRunning при создании задачи

• настраивает оптимизационные алгоритмы планировщика по анализу эффективности выполнения задач
• планировщик не отслеживает эффективность выполнения задачи в рабочем потоке
• для задачи создается новый поток, не входящий в число рабочих потоков
• рабочий поток выполнения задачи получает низкий приоритет
• рабочий поток выполнения задачи получает высокий приоритет

Методы Parallel.For, Parallel.Invoke позволяют

• задать число потоков, которые используются для обработки пользовательских задач
• задать максимальное число потоков, которые используются для обработки пользовательских задач
• задать минимальное число потоков, которые используются для обработки пользовательских задач
• методы не позволяют регулировать число потоков

Вложенные задачи выполняются (с учетом действия всех стратегий планировщика):

• в том же рабочем потоке, что и родительская задача
• могут выполняться в разных рабочих потоках
• если являются дочерними, то выполняются в одном рабочем потоке.
• ни одно из представленных утверждений не верно

Оптимизация относительного расположения данных в памяти позволяет снять проблему:

• гонка данных
• ложное разделение кэша
• взаимоблокировка
• сбалансированность нагрузки

Для осуществления заимствования рабочим потоком Thread1 задачи из локальной очереди потока Thread2 необходимо соблюдение следующих условий:

• глобальная очередь содержит элементы
• глобальная очередь не содержит элементов
• рабочий поток Thread1 свободен
• другие рабочие потоки заняты

Следующий фрагмент приводит к действиям планировщика: static void Main() { Thread thread = new Thread(() => { f1(); Task t = Task.Factory.StartNew(() => f2()); }); thread.Start(); }

• методы f1 и f2 обрабатываются в одном пользовательском потоке
• методы f1 и f2 обрабатываются в одном рабочем потоке
• методы f1 обрабатывается в пользовательском потоке, метод f2 добавляется в глобальную очередь и обрабатывается одним из рабочих потоков
• метод f1 обрабатывается в пользовательском потоке, метод f2 добавляется в локальную очередь этого же потока

Для помещения вложенной задачи в глобальную очередь потока необходимо

• использовать параметр LongRunning при создании задачи
• использовать параметр RunSynchronously
• вложенные задачи помещаются только в локальную очередь рабочего потока
• использовать параметр PreferFairness при создании задачи

Для отмены выполняющегося PLINQ-запроса можно использовать

• метод Cancel объекта CancellationTokenSource
• метод Cancel объекта ParallelQuery
• метод Stop объекта ParallelQuery
• не существует возможности отменить выполняющийся запрос

Агрегированные вычисления могут осуществляться параллельно для следующих операторов

• Min
• Max
• Aggregate
• агрегированные вычисления осуществляются только последовательно

Каким образом можно распараллелить следующий LINQ-запрос? var q = from n in numbers where n % 2 > 0 select n;

• модификация запроса не требуется. Обработка запросов в C# 4.0 автоматически распараллеливается.
• добавить вызов метода AsParallel() для источника данных
• добавить служебные слова as parallel в конец запроса
• использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()

Объявление Task t2 = t1.ContinueWith(..) гарантирует

• запуск задачи t2 только после завершения задачи t1
• запуск задачи t2 до завершения задачи t1
• запуск задачи t2 при определенном статусе завершения задачи t1
• нет правильного ответа

При возникновении необработанного исключения в задаче:

• статус задачи Faulted
• статус задачи Canceled
• статус задачи не определен
• нет правильных ответов

Какие средства синхронизации используют вызовы ядра операционной системы?

• Mutex
• ManualResetEvent
• AutoResetEvent
• Monitor

Преимущества использования многопоточности для параллельных вычислений по сравнению с применением многопроцессности связаны:

• потоки работают в едином адресном пространстве
• переключение потоков одного процесса занимает меньшее время по сравнению с переключением потоков разных процессов
• для взаимодействия потоков не требуется применения средств синхронизации
• сбой в одном потоке не приводит к сбою приложения

В чем преимущества использования пула потоков для параллельной обработки?

• рабочие потоки пула являются более легковесными объектами
• нет накладных расходов на создание и завершение потоков
• распределение рабочих элементов по потокам осуществляется автоматически
• пул потоков предоставляет встроенные механизмы ожидания завершения работы, механизм отмены

Метод Thread.Yield игнорируется в случае:

• нет конкуренции за ядро, на котором выполняется текущий поток
• нет потоков с большим приоритетом, чем приоритет текущего потока
• приложение выполняется на одноядерном процессоре
• нет правильных ответов

В какое состояние может перейти поток после завершения операции ввода-вывода, если до операции поток выполнялся?

• "Приостановленный"
• "Ожидающий"
• "Выполняющийся"
• "Готовый"

Какое предельное ускорение может быть получено согласно закону Амдала для параллельной программы, содержащей 40% параллельного кода

• 4
• 5
• 10
• нет правильных ответов

Параллельный алгоритм работает в два раза быстрее последовательного на четырех ядерной системе. Чему равна эффективность алгоритма?

• 0.5
• 1
• 2
• не хватает данных для расчета эффективности

Выберете правильные утверждения, соответствующие свойству масштабируемости параллельного приложения

• приложение обеспечивает ускорение, равное предельному, согласно закону Амдала
• приложение может обрабатывать разные объемы данных
• приложение максимально задействует все имеющиеся вычислительные ресурсы
• нет правильных вариантов

В каких случаях обеспечивается относительно равномерная загрузка потоков

• объем, выполняемой работы каждым потоком, одинаков
• осуществляется динамическая (блочная) декомпозиция обработки элементов
• потоки обрабатывают одинаковое число элементов общей структуры данных
• при функциональной декомпозиции выделяется число подзадач равное числу потоков

В каких случаях возникает проблема гонки данных:

• потоки осуществляют запись в разделяемую переменную
• один поток осуществляет запись в разделяемую переменную, а другой поток читает разделяемую переменную
• потоки увеличивают общий счетчик, выполняя оператор инкрементирования
• два потока добавляют элементы в один список типа очереди (Queue)

Второй аргумент в вызове метода пула потоков задает:ThreadPool.QueueUserWorkItem(f, 5);

• число потоков, которые будет выполнять метод f
• время до запуска метода f
• число копий метода f, которые добавляются в пул потоков
• аргумент метода f

Параметр PreferFairness позволяет

• выделить независимый поток для задачи
• изменить дисциплину локальной очереди с LIFO на FIFO
• добавить задачу в конец локальной очереди рабочего потока
• ни один из перечисленных вариантов

Какие средства синхронизации позволяют организовать барьерную синхронизацию (один поток дожидается завершения нескольких потоков):

• Monitor
• SemaphoreSlim
• Mutex
• Lock

В рабочей функции потока используется переменная SomeVal типа int. Переменная является локальной для каждого потока в следующих случаях:

• переменная объявлена внутри рабочей функции потока
• переменная класса, используемого в рабочей функции, объявлена с модификатором private.
• переменная класса, используемого в рабочей функции, объявлена с атрибутом ThreadStaticAttribute
• переменная объявлена внутри класса, содержащего рабочую функцию потока

Родительская задача ParentTask завершается без исключений, во вложенной (не дочерней) задаче innerTask возникает исключение. Статусы задач:

• ParentTask.Status: RanToCompletion, innerTask.Status: Faulted
• ParentTask.Status: Faulted, innerTask.Status: Faulted
• ParentTask.Status: Canceled, innerTask.Status: Faulted
• ParentTask.Status: Canceled, innerTask.Status: Canceled

Декомпозиция по диапазону позволяет эффективнее обрабатывать:

• декомпозиция по диапазону не является эффективной
• итерации с большой вычислительной нагрузкой
• элементы структуры с равной вычислительной нагрузкой обработки каждого элемента
• элементы структуры с неравномерной вычислительной нагрузкой обработки каждого элемента

Какие средства синхронизации можно использовать для организации параллельного доступа нескольких потоков к ресурсу?

• Semaphore
• Mutex
• AutoResetEvent
• lock

Задачи-продолжения позволяют:

• реализовать обработчик отмены задач
• запускать задачу при определенном статусе завершения предшествующей задачи
• запускать задачу при определенном статусе завершения предшествующей задачи
• нет правильных вариантов

Следующий запрос выполняется var q = ParallelEnumerable.Range(1, N).Where(n=>true).Take(10).ToArray();

• параллельно
• последовательно
• параллельно или последовательно в зависимости от величины N
• нет правильных вариантов

Какое предельное ускорение может быть получено согласно закону Амдала для параллельной программы, содержащей 20% последовательного кода

• 2
• 5
• 10
• нет правильных ответов

Блочное (динамическое) разделение данных осуществляется при выполнении следующего PLINQ-запроса:

• Partitioner.Create(ParallelData, true).Where(item=>f(item)).Select(item=>f(item);
• ParallelEnumerable.Range(1, 1000).Where(i => i%5 == 0).Select(i=> i*i);
• ParallelData.Select(o => f(o)).GroupBy(o.Key);
• блочное разделение данных осуществляется во всех PLINQ-запросах

Блок try для обработки исключений, возникающий при выполнении PLINQ-запроса, обрамляет:

• определение запроса
• обращение к методам ToList, ToArray, ToDictionary
• перебор элементов запроса в for- или foreach-цикле
• обработка исключений осуществляется внутри запроса

Какой запрос выполняется последовательно

• ParallelEnumerable.Range(1, N).Where(n=>true).Take(5).ToArray();
• ParallelEnumerable.Range(1, N).Take(5).ToArray();
• ParallelEnumerable.Range(1, N).SelectMany(i => f(i)).ToArray();
• ParallelEnumerable.Range(1, N).Where(n=> n % 2 == 0).ToArray();

Метод Parallel.For позволяет:

• выполнять агрегированные вычисления
• осуществлять параллельную обработку независимых итераций
• осуществлять досрочный выход из цикла
• распараллеливать произвольный for-цикл

Объект Monitor поддерживает следующие возможности

• попытка входа в критическую секцию в течение заданного интервала времени
• попытка входа в критическую секцию
• вход в критическую секцию нескольких потоков
• синхронизация на уровне операционной системы (межпроцессная синхронизация)

Выберете утверждения, соответствующие многоядерной архитектуре

• вычислительная система содержит несколько исполнительных устройств, работающих с общей памятью
• вычислительная система содержит одно исполнительное устройство и несколько блоков кэшируемой памяти
• вычислительная система содержит несколько исполнительных устройств, каждое из которых работает со своей оперативной памятью
• нет правильных ответов

Задачи-продолжения запускаются после завершения задачи предшественника

• вне зависимости от исхода задачи
• если не было отмены задачи предшественника
• если не было исключения в предшествующей задаче
• в зависимости от статуса завершения предшествующей задачи и параметров задачи-продолжения

Для параллельного выполнения следующего LINQ-запроса необходимо: var q = Enumerable.Range(1, 100000).Select( i => f(i)).Where(d => d% 11);

• добавить вызов метода AsParallel перед методом Select
• добавить вызов метода AsParallel в конец запроса
• добавить вызов метода AsParallel перед методом Range
• использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()

Какой вывод для следующего фрагмента является наиболее вероятным: Task t = Task.Factory.StartNew( () => { Task t1 = Task.Factory.StartNew( () => Console.Write (“1”)); Task t2 = Task.Factory.StartNew( () => Console.Write (“2”)); Console.Write (“3”); });

• 123
• 132
• 321
• ни один из перечисленных вариантов

В рабочей функции потока используется переменная SomeVal типа int. Переменная является общей в следующих случаях:

• переменная объявлена внутри рабочей функции потока
• переменная класса, используемого в рабочей функции, объявлена с модификатором public.
• переменная класса, используемого в рабочей функции, объявлена с атрибутом ThreadStaticAttribute
• переменная объявлена внутри класса, содержащего рабочую функцию потока

Какой объект синхронизации можно использовать для предотвращения запуска нескольких копий одного приложения?

• Monitor
• Mutex
• Interlocked
• SemaphoreSlim

В каком случае не осуществляется заимствование задач из локальной очереди загруженного потока?

• есть задачи в глобальной очереди
• режим WorkStealing выключен с помощью опций планировщика
• все рабочие потоки заняты обработкой
• задачи в локальной очереди созданы с опцией PreferFairness

Число рабочих потоков, участвующих при обработке задач, зависит от следующих факторов::

• вычислительные возможности системы (число ядер)
• параметры пула потоков
• результаты обработки предыдущих задач
• нет правильных ответов

Если вложенные задачи выполняются в том же потоке, что и родительская задача, то порядок выполнения следующий:

• в том же порядке, в каком помещаются в локальную очередь
• в обратном порядке
• порядок выполнения вложенных задач в рабочем потоке является неопределенным

Для изменения порядка обработки вложенных задач, находящихся в локальной очереди потока, необходимо:

• использовать параметр PreferFairness при создании задачи
• использовать параметр ExecuteSynchronously
• использовать параметр LongRunning
• не существует такой возможности

Задача t2.3 ожидает завершения задачи t2.2, находящейся в локальной очереди рабочего потока. Стратегия inlined execution приведет

• задача t2.2 будет выполняться в том же рабочем потоке, что и t2.3.
• задача t2.2 будет выполняться в другом свободном рабочем потоке
• задача t2.3 будет выгружена и добавлена в глобальную очередь
• задача t2.3 будет выгружена и добавлена в конец локальной очереди

Какой вывод наиболее вероятен для следующего фрагмента: static void Main() { Task t1 = Task.Factory.StartNew(() => Console.Write(“A”)); Task t2 = Task.Factory.StartNew(() => { Task t3 = Task.Factory.StartNew(() => Console.Write(“B”)); Console.Write(“C”); }); }

• ACB
• BCA
• CBA
• ни один из перечисленных вариантов не возможен

Какие запросы выполняются параллельно?

• ParallelEnumerable.Range(1, N).Where(n=>true).Take(5).ToArray();
• ParallelEnumerable.Range(1, N).Take(5).ToArray();
• ParallelEnumerable.Range(1, N).Where(n=> n % 2 == 0).Take(5).ToArray();
• ParallelEnumerable.Range(1, N).Where(n=> n % 2 == 0).ToArray();

Можно ли выполнить досрочную остановку выполнения PLINQ-запроса?

• методы Stop и Break объекта ParallelLoopState
• с помощью токена отмены
• не существует возможности досрочной остановки
• с помощью генерации исключения при обработке элементов

Какой из перечисленных LINQ-операторов обладает наименьшей эффективностью распараллеливания:

• Where
• Distinct
• Max
• Select

Каким образом можно распараллелить следующий LINQ-запрос? var q = data.Select(item => f(item)).Where(o => p(o));

• модификация запроса не требуется. Обработка запросов в C# 4.0 автоматически распараллеливается.
• добавить модификатор AsParallel() после источника данных
• добавить модификатор AsParallel() в конец запроса
• использовать параметр ParallelOptions при выполнении запроса Select
• использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()

При выполнении параллельной обработки с помощью метода Parallel.ForEach

• число потоков задается в качестве аргумента метода Parallel.ForEach
• число потоков определяется количеством итераций на этапе инициализации обработки
• число потоков может динамически изменяться, но не больше числа ядер вычислительной системы
• число потоков может динамически изменяться

При осуществлении пакетной обработки с помощью метода Parallel.ForEach синхронизация необходима

• на этапе инициализации
• на этапе выполнения обработки
• на этапе финальной редукции
• необходимость применения синхронизации зависит от выполняемой обработки

Какому методу или методам соответствует оператор break при распараллеливании циклической обработки с помощью Parallel.For?

• Abort
• Break
• Stop
• для параллельных циклов не существует оператора досрочного выхода

Блочная (динамическая) декомпозиция позволяет эффективнее обрабатывать:

• итерации с малой вычислительной нагрузкой
• элементы структуры с равной вычислительной нагрузкой обработки каждого элемента
• элементы структуры с неравномерной вычислительной нагрузкой обработки каждого элемента
• блочная декомпозиция не является эффективной

Реализация агрегированных вычислений с помощью метода Parallel.For

• метод Parallel.For используется только для распараллеливания независимых вычислений и не предназначен для агрегированных вычислений
• необходимость использования блокировок определяется алгоритмом агрегированных вычислений.
• не требует использования блокировок
• требует использования блокировок

Одновременный запуск нескольких задач (добавление в очередь готовых задач) осуществляется в следующих фрагментах кода:

• Task t1 = new Task(f1); Task t2 = new Task(f2); Task t3 = new Task(f3); Task.StartAll(t1, t2, t3); Task.WaitAll(t1, t2, t3);
• Task t1 = new Task(f1); Task t2 = new Task(f2); Task t3 = new Task(f3); Parallel.Invoke(t1, t2, t3);
• Task t1 = Task.Factory.StartNew(f1); Task t2 = Task.Factory.StartNew(f2); Task t3 = Task.Factory.StartNew(f3); Task.WaitAll(new Task[] {t1, t2, t3});
• Parallel.Invoke(new Task[] {f1, f2, f3});

Метод Flatten применяется для

• преобразования типа AggregateException в тип Exception
• назначения обработчиков конкретных исключений
• получения списка исключений, возникнувших при исполнении задач
• нет верных утверждений

Для ожидания завершения задачи типа Task можно использовать

• вызов метода Wait
• вызов метода Join для потока, в котором выполняется задача
• обращение к свойству Result
• вызов статического метода Task.WaitAll с указанием задачи в качестве параметра

Обращение к свойству Result задачи, которая еще выполняется

• блокирует поток до завершения задачи
• генерирует исключение
• возвращает null
• ни один из предложенных вариантов

В каких случаях задача завершается со статусом Faulted

• во вложенных задачах возникли исключения
• задача была отменена
• в дочерних задачах возникли исключения
• в задаче возникло исключение

При выполнении операции добавления Add для объекта типа BlockedCollection, содержащего максимальное число элементов и без вызова CompleteAdding, происходит:

• блокировка текущего потока
• метод возвращает null
• генерируется исключение
• нет правильного ответа

Сигнальные сообщения типа AutoResetEvent позволяют:

• реализовать взаимно-исключительный доступ к фрагменту кода
• реализовать доступ заданного числа потоков к фрагменту кода
• реализовать одновременный запуск всех заблокированных потоков
• реализовать запуск только одного из ожидающих потоков

Метод WaitOne объекта синхронизации Semaphore не приводит к блокировке в случае

• метод WaitOne всегда приводит к блокировке потоков в ожидании сигнала об освобождении объекта синхронизации
• объект Semaphore инициирован ненулевым начальным состоянием
• вызову метода WaitOne предшествовал вызов Release с ненулевым значением аргумента
• объект Semaphore установлен в ненулевое состояние с помощью метода Set

Какие средства синхронизации позволяют избежать «мертвой блокировки» ожидающих потоков при возникновении сбоя внутри критической секции?

• lock
• Semaphore
• Mutex
• AutoResetEvent

Какие средства синхронизации можно использовать в нескольких приложениях?

• Semaphore
• SemaphoreSlim
• Mutex
• Monitor

Какие средства синхронизации можно использовать для организации взаимно-исключительный доступ к разделяемому ресурсу?

• Mutex
• SemaphoreSlim
• lock
• ManualResetEvent

Применение многопоточности для параллельных вычислений связано со следующими недостатками:

• для взаимодействия потоков требуется применение специальных средств обмена сообщениями
• для согласования поведения потоков необходимо применение средств синхронизации
• сбой в одном потоке приводит к сбою приложения
• многопоточное выполнение приложения связано с накладными расходами, превышающими расходы при многопроцессном выполнении

Для ожидания завершения обработки пользовательских рабочих элементов пулом потоков можно использовать

• ThreadPool.Wait
• ThreadPool.WaitAll
• Thread.Join
• нет правильных вариантов

Для передачи управления другому потоку, конкурирующему за ядро процессора, на котором выполняется данный поток без прекращения его работы, можно использовать:

• Thread.Yield
• Thread.Sleep(0)
• Thread.Stop
• нет средств для передачи управления без прекращения работы текущего потока

Локальное хранилище потоков может использоваться для хранения

• только статические поля класса, доступного в рабочей функции потока
• только значимые типы (value types)
• только встроенные типы
• нет правильных ответов

Число рабочих потоков в пуле зависит от следующих факторов:

• возможности вычислительной системы (число процессоров/ядер)
• загруженность вычислительной системы
• параметры пула потоков
• число рабочих элементов, добавленных в пул потоков

При каких условиях поток находится в состоянии "Готовый"?

• создан экземпляр класса Thread.
• объект типа Thread запущен с помощью метода Start
• поток выполняется на процессоре (ядре процессора)
• выполняющийся поток выгружен по истечении кванта времени

Параллельный алгоритм состоит из двух подзадач и обеспечивает ускорение в два раза на двуядерной системе. Чему равна эффективность алгоритма системе с четырьмя процессорами?

• 0.25
• 0.5
• 1
• 2

Проблема ложного разделения кэша связана

• потоки используют разделяемую переменную
• потоки используют разные переменные, которые расположены в памяти физически близко
• потоки работают с большим объемом данных, превышающим размер кэша
• нет правильных ответов

В каких случаях не возникает проблема гонки данных

• один поток добавляет элементы в коллекцию типа FIFO (очередь), другой поток извлекает элементы из коллекции
• потоки инкрементируют значения, которые хранятся в разделяемом массиве; каждый поток работает с элементом по уникальному индексу
• потоки осуществляют запись в разделяемую переменную типа int
• один поток осуществляет запись в разделяемую переменную типа double, другой поток читает значения

В каких состояниях может находиться поток в процессе работы, если он не выполняет операций ввода-вывода, обращений к функциям ядра и не приостанавливается другими потоками?

• "Готовый"
• "Ожидающий"
• "Приостановленный"
• "Выполняющийся"

Параллельный алгоритм состоит из четырех подзадач, которые начинают выполняться одновременно. Время работы каждой подзадачи составляет: 1, 2, 3 и 4 мс соответственно. Чему равно общее время работы алгоритма, если затратами на подготовку подзадач и агрегирование результатов можно пренебречь?

• 2.5
• 10
• 4
• 3

Какое предельное ускорение может быть получено согласно закону Амдала для параллельной программы, содержащей 80% параллельного кода

• 8
• 5
• 16
• нет правильных ответов