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

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

700,00 руб.
В течение часа!
Экзамен "Параллельное программирование с помощью языка C#" для пользователей и системных администраторов.
Количество
Есть в наличии!

Форма сдачи теста: Экстерн
Количество вопросов: 30
Проходной балл: 90% и выше
Срок действия сертификата: неограничен

Сертификат появляется в профиле ресурса INTUIT, и Вы можете заказать его бумажную версию на сайте INTUIT.
12558 шт.
Внимание !
Вопросы к тесту выложены исключительно в ознакомительных целях: количество вопросов может не совпадать с действительным, актуальность не поддерживается,- за решением теста Welcome to the cashier!

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

4
2.5
10
3


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

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


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

1
0.5
2
0.25


Параллельный алгоритм состоит из четырех независимых подзадач, которые выполняются за одинаковое время. Ускорение алгоритма на двуядерной системе составляет 1.5. Чему равно ускорение алгоритма на четырех ядерной системе?

1.5
6
3
2


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

создать экземпляр класса ThreadPool
использовать метод для добавления рабочих элементов QueueUserWorkItem
использовать метод для начала работы пула Start
задать параметры пула потоков


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

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


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

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


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

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


Вызов метода Thread.Sleep(0) приводит к следующему:

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


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

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


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

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


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

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


Объект ThreadPool позволяет:

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


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

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


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

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


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

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


Применение многопроцессного выполнения связано со следующими проблемами:

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


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

lock
Mutex
ManualResetEvent
SemaphoreSlim


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

Interlocked
Monitor
ConcurrentBag
SpinWait


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

Semaphore
lock
AutoResetEvent
Mutex


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

Semaphore
Mutex
Monitor
SemaphoreSlim


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

Mutex
AutoResetEvent
ManualResetEvent
Monitor


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

Monitor
Interlocked
SemaphoreSlim
Mutex


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

Lock
Monitor
Mutex
SemaphoreSlim


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

Mutex
AutoResetEvent
lock
Semaphore


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

AutoResetEvent
lock
Mutex
Semaphore


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

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


Класс Monitor поддерживает следующие возможности:

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


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

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


Объект Semaphore обладает следующими возможностями:

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


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

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


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

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


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

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


Выберете правильные утверждения

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


Выберете правильные утверждения

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


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

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


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

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


Выберете правильные утверждения

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


Выберете правильные утверждения

метод Start запускает задачу в текущем потоке
метод Task.Factoy.StartNew создает новый поток для задачи
метод Start добавляет задачу в очередь пула потоков
метод Task.Factory.StartNew запускает задачу в рабочем потоке и дожидается завершения работы


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


Конкурентные коллекции типа ConcurrentStack<T>, ConcurrentQueue<T>, ConcurrentBag<T> можно создавать:

конкурентные коллекции нельзя создавать на базе других объектов
на базе объектов любых типов, реализующих интерфейс IEnumerable
все конкурентные коллекции можно создавать на базе соответствующих коллекций (ConcurrentStack<T> только на базе Stack<T>)
нет правильных ответов


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

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


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

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


Выберете правильные утверждения

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


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

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


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


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

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

Внимание !
Вопросы к тесту выложены исключительно в ознакомительных целях: количество вопросов может не совпадать с действительным, актуальность не поддерживается,- за решением теста Welcome to the cashier!

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

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


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

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


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

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


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

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


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

последовательный цикл for.
Parallel.ForEach с пакетной обработкой итераций
Parallel.ForEach с блочной декомпозицей
Paralle.Invoke


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

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


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

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


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

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


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

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


Вызов метода CompleteAdding для объекта типа BlockingCollection<T> приводит к:

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


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

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


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

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


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

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


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

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


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

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


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

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


Для параллельного выполнения следующего LINQ-запроса необходимо:

 var q = Enumerable.Range(1, 100000).Select( i => f(i)).Where(d => d% 11);
 
добавить вызов метода AsParallel в конец запроса
добавить вызов метода AsParallel перед методом Range
использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()
добавить вызов метода AsParallel перед методом Select


Каким образом можно распараллелить следующий LINQ-запрос?

  var q = data.Select(item => f(item)).Where(o => p(o));
 
использовать параметр ParallelOptions при выполнении запроса Select
добавить модификатор AsParallel() в конец запроса
использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()
модификация запроса не требуется. Обработка запросов в C# 4.0 автоматически распараллеливается.
добавить модификатор AsParallel() после источника данных


Каким образом можно распараллелить следующий LINQ-запрос?

  var q = from n in numbers
  where n % 2 > 0 
  select n;
 
добавить вызов метода AsParallel() для источника данных
использовать параметр ParallelOptions при выполнении запроса в методе ToList() или ToArray()
модификация запроса не требуется. Обработка запросов в C# 4.0 автоматически распараллеливается.
добавить служебные слова as parallel в конец запроса


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

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


Хэш-секционирование для разделения данных используется в следующих фрагментах:

ни в одном из фрагментов не применяется хэш-секционирование
var q = ParallelData.Wherede(o => f(o));
var q = ParallelData.Distinct();
var q = ParallelData.GroupBy(o => o.Key);


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

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

var q = ParallelEnumerable.Range(1, 1000).Where(i => i%5 == 0).Select(i=> i*i);

>var q = Partitioner.Create(ParallelData, true)
 Where(item=>f(item)).Select(item=>f(item);

var q = ParallelData.GroupBy(o.Key);


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

SelectMany
AsUnordered
Aggregate
WithCancellation


Какие LINQ-операторы снижают эффективность распараллеливания:

WithMergeOptions(ParallelMergeOptions.NotBuffered)
WithCancellation
WithMergeOptions(ParallelMergeOptions.FullyBuffered)
AsOrdered


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

Max
Select
Where
Distinct


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

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


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

нет правильного ответа
Distinct, GroupBy
Aggregate
Min, Max


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


Следующий запрос выполняется

  var q = ParallelEnumerable.Range(1, N).Where(n=>true).Take(10).ToArray();
 
нет правильных вариантов
параллельно или последовательно в зависимости от величины N
последовательно
параллельно


Какой вывод наиболее вероятен для следующего фрагмента:

 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”);
 });
 }
 
CBA
ни один из перечисленных вариантов не возможен
BCA
ACB


Какой вывод для следующего фрагмента является наиболее вероятным:

 Task t = Task.Factory.StartNew( () =>
 {
  Task t1 = Task.Factory.StartNew( () =>
  Console.Write (“1”));
  Task t2 = Task.Factory.StartNew( () =>
  Console.Write (“2”));
  Console.Write (“3”);
 });
 
321
ни один из перечисленных вариантов
132
123


Следующий фрагмент кода приводит к действиям планировщика:

 static void Main()
 {
 ..
 Task t1 = Task.Factory.StartNew( () =>
 SomeWork());
 Task t2 = Task.Factory.StartNew( () =>
 SoweWork());
 ..
 }
 
ни один из перечисленных вариантов
задачи t1 и t2 помещаются в глобальную очередь пула потоков
задачи t1 и t2 помещаются в одну и ту же локальную очередь рабочего потока
задачи t1 и t2 помещаются в локальные очереди разных рабочих потоков


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

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


Технология Inlined execution предназначена для оптимизации выполнения:

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


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

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


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

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


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

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


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

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


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

использовать параметр PreferFairness при создании задачи
ни один из перечисленных вариантов
использовать параметр LongRunning при создании задачи
использовать параметр ExecuteSynchronously при создании задачи


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

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


Какие методы типа Task и объекта типа Task предполагают блокировку текущего потока до завершения задачи

t.ContinueWith
Task.WaitAll
t.Wait
Task.Factory.StartNew


Выберете правильные утверждения

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


Следующий фрагмент приводит к действиям планировщика:

 static void Main()
 {
 Thread thread = new Thread(() => {
 
  f1();
  Task t = Task.Factory.StartNew(() => f2());
  });
 thread.Start();
 }
 
методы f1 и f2 обрабатываются в одном рабочем потоке
методы f1 и f2 обрабатываются в одном пользовательском потоке
метод f1 обрабатывается в пользовательском потоке, метод f2 добавляется в локальную очередь этого же потока
методы f1 обрабатывается в пользовательском потоке, метод f2 добавляется в глобальную очередь и обрабатывается одним из рабочих потоков


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

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


Следующий фрагмент приводит к действиям планировщика:

 static void Main()
 {
 Thread thread = new Thread(() => {
 
 Parallel.Invoke(f1, f2);
 f3();
 });
 thread.Start();
 }
 
 
>нет правильных вариантов
методы f1,f2,f3 добавляются в локальную очередь пользовательского потока
методы f1, f2, f3 всегда обрабатываются в одном рабочем потоке
методы f1,f2,f3 всегда обрабатываются в одном пользовательском потоке


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

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


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

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


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

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


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

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


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

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


Следующий фрагмент приводит к действиям планировщика

 static void Main()
 {
  ThreadPool.QueueUserWorkItem(f1,);
  ThreadPool.QueueUserWorkItem(f2,);
  ThreadPool.QueueUserWorkItem(f3);
 }
 
неявно созданные задачи, связанные с методами f1, f2, f3, помещаются в глобальную очередь
неявно созданные задачи, связанные с методами f1, f2, f3, помещаются в локальную очередь текущего потока
методы f1, f2, f3 обрабатываются в трех созданных потоках, не входящих в пул рабочих потоков
нет правильных вариантов

Вы можете обратится к нам напрямую, через:

skype По Skype: molodoyberkut
telegram По Telegram: @MolodoyBerkut
icq По ICQ: 657089516

Или через форму обратной связи на нашем сайте
Пока сочиняется...
4.png