Самый быстрый способ асинхронного выполнения метода?

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

в настоящее время я застрял с

ThreadPool.UnsafeQueueUserWorkItem

как немного быстрее обычного QueueUserWorkItem. однако, я боюсь, что threadpool может заблокировать это здесь. есть ли более быстрый способ отправки вызова метода в другой поток? Я просто задаюсь вопросом, что лучше всего подходит для такой задачи? небезопасный код не будет проблемой, так как он находится в сценарии, где уже используется много interop. благодаря к.

Ответ 1

Команда CLR (4) рекомендует:

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

Считать CLR 4.0 Улучшения ThreadPool: Часть 1 и Новые и улучшенные CLR 4 Thread Pool Engine для получения подробной информации. Короче говоря, причины: локальные очереди, повторное использование потоков, кража работы. Базовый для целей балансировки нагрузки.

Дополнительно:

Я не понимаю, почему это не ответ (downvoted).

Вы написали

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

Я отвечаю: Некоторые TPL (существует для net35) "блоки" ( параллельные коллекции, прядильные примитивы и т.д.) Предназначены специально для высококонкурентного доступа, а фокусируется на минимизации или устранении блокировки для эффективного управление работой. Вы можете также использовать эти блоки (например, BlockingCollection для вашей проблемы). TPL предназначен для создания и обработки сотен (или даже тысяч) операций (задач) cpu/io-bound с минимальными накладными расходами (или миллионы с помощью PLinq).

Вы спросили:

Я просто задаюсь вопросом, что лучше всего подходит для такой задачи?

Я уже ответил: лучшая практика - TPL (аргументированная, а не только моя рекомендация)

Ответ 2

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

Отредактировано после прочтения одного из ваших комментариев:

У меня были подобные вещи. Мое обычное средство состоит в том, чтобы не отправлять каждый асинхронный запрос немедленно, а скорее имитировать то, что "Алгоритм Нагле" для TCP.

Здесь, получив Request(), вы немедленно отправите его, только если асинхронная работа не ожидается. Если ожидаемая асинхронная работа будет отправлена, вы отправите ее только в том случае, если определенное количество миллисекунд с самого раннего нераспределенного Запроса прошло или накоплено определенное количество оставшихся запросов().

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

Ответ 3

Возможно, вы могли бы отправить все ваши запросы на отправку в List < > и просыпать еще один фоновый поток, чтобы сделать вызовы QueueUserWorkItem.

Я правильно понимаю проблему?