Каков наилучший способ заставить несколько потоков работать, и ждать, пока все они завершатся?

Ответ 1

Простейшим может быть создание новых потоков, а затем вызов Thread.Join для каждого из них. Вы можете использовать семафор или что-то в этом роде, но, возможно, проще просто создать новые потоки.

В .NET 4.0 вы можете использовать Parallel Extensions, чтобы сделать это довольно легко с задачами.

В качестве другой альтернативы, которая будет использовать threadpool, вы можете создать делегат и называть BeginInvoke на нем, чтобы вернуть IAsyncResult - вы можете получить WaitHandle для каждого результата через AsyncWaitHandle и вызовите WaitHandle.WaitAll.

EDIT: Как указано в комментариях, вы можете вызывать только WaitAll с 64 ручками одновременно на некоторых реализациях. Альтернативы могут вызывать WaitOne на каждом из них по очереди или вызывать WaitAll с партиями. Это не имеет большого значения, если вы делаете это из потока, который не собирается блокировать threadpool. Также обратите внимание, что вы не можете вызывать WaitAll из потока STA.

Ответ 2

Вы все еще хотите использовать ThreadPool, потому что он будет управлять количеством потоков, которые он запускает одновременно. Недавно я столкнулся с подобной проблемой и решил ее так:

var dispatcher = new ThreadPoolDispatcher();
dispatcher = new ChunkingDispatcher(dispatcher, 10);

foreach (var image in images)
{
    dispatcher.Add(new ResizeJob(image));
}

dispatcher.WaitForJobsToFinish();

IDispatcher и IJob выглядят следующим образом:

public interface IJob
{
    void Execute();
}

public class ThreadPoolDispatcher : IDispatcher
{
    private IList<ManualResetEvent> resetEvents = new List<ManualResetEvent>();

    public void Dispatch(IJob job)
    {
        var resetEvent = CreateAndTrackResetEvent();
        var worker = new ThreadPoolWorker(job, resetEvent);
        ThreadPool.QueueUserWorkItem(new WaitCallback(worker.ThreadPoolCallback));
    }

    private ManualResetEvent CreateAndTrackResetEvent()
    {
        var resetEvent = new ManualResetEvent(false);
        resetEvents.Add(resetEvent);
        return resetEvent;
    }

    public void WaitForJobsToFinish()
    {
        WaitHandle.WaitAll(resetEvents.ToArray() ?? new ManualResetEvent[] { });
        resetEvents.Clear();
    }
}

И затем использовал декоратор для использования ThreadPool:

public class ChunkingDispatcher : IDispatcher
{
    private IDispatcher dispatcher;
    private int numberOfJobsDispatched;
    private int chunkSize;

    public ChunkingDispatcher(IDispatcher dispatcher, int chunkSize)
    {
        this.dispatcher = dispatcher;
        this.chunkSize = chunkSize;
    }

    public void Dispatch(IJob job)
    {
        dispatcher.Dispatch(job);

        if (++numberOfJobsDispatched % chunkSize == 0)
            WaitForJobsToFinish();
    }

    public void WaitForJobsToFinish()
    {
        dispatcher.WaitForJobsToFinish();
    }
}

Абстракция IDispatcher работает очень хорошо для замены вашей технологии потоковой обработки. У меня есть другая реализация, которая является SingleThreadedDispatcher, и вы можете сделать версию ThreadStart, например, предложенную Джоном Скитом. Затем легко запустить каждый из них и посмотреть, какую производительность вы получите. SingleThreadedDispatcher хорош при отладке вашего кода или когда вы не хотите убивать процессор на вашем поле.

Изменить: Я забыл добавить код для ThreadPoolWorker:

public class ThreadPoolWorker
{
    private IJob job;
    private ManualResetEvent doneEvent;

    public ThreadPoolWorker(IJob job, ManualResetEvent doneEvent)
    {
        this.job = job;
        this.doneEvent = doneEvent;
    }

    public void ThreadPoolCallback(object state)
    {
        try
        {
            job.Execute();
        }
        finally
        {
            doneEvent.Set();
        }
    }
}

Ответ 3

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

Вот пример

int itemCount = 0;
for (int i = 0; i < 5000; i++)
{
    Interlocked.Increment(ref itemCount);

    ThreadPool.QueueUserWorkItem(x=>{
        try
        {
            //code logic here.. sleep is just for demo
            Thread.Sleep(100);
        }
        finally
        {
            Interlocked.Decrement(ref itemCount);
        }
    });
}

while (itemCount > 0)
{
    Console.WriteLine("Waiting for " + itemCount + " threads...");
    Thread.Sleep(100);
}
Console.WriteLine("All Done!");

Ответ 4

.Net 4.0 делает многопоточность еще проще (хотя вы все равно можете снимать себя с побочными эффектами).

Ответ 5

Я использовал SmartThreadPool с большим успехом, чтобы справиться с этой проблемой. Существует также Codeplex сайт о сборке.

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

Ответ 6

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

    public static void WaitAll(WaitHandle[] handles)
    {
        if (handles == null)
            throw new ArgumentNullException("handles",
                "WaitHandle[] handles was null");
        foreach (WaitHandle wh in handles) wh.WaitOne();
    }

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

 List<WaitHandle> waitHndls = new List<WaitHandle>();
 foreach (iterator logic )
 {
      ManualResetEvent txEvnt = new ManualResetEvent(false);

      ThreadPool.QueueUserWorkItem(
           delegate
               {
                   try { // Code to process each task... }
                   // Finally, set each wait handle when done
                   finally { lock (locker) txEvnt.Set(); } 
               });
      waitHndls.Add(txEvnt);  // Add wait handle to List
 }
 util.WaitAll(waitHndls.ToArray());   // Check all wait Handles in List

Ответ 7

Другой вариант - использовать трубку.

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

Ответ 8

Я предлагаю помещать нетронутые изображения в очередь и, когда вы читаете из очереди, запускаете поток и вставляете его свойство System.Threading.Thread.ManagedThreadId в словарь вместе с именем файла. Таким образом, ваш пользовательский интерфейс может отображать как ожидающие, так и активные файлы.

Когда каждый поток завершается, он вызывает процедуру обратного вызова, возвращая свой ManagedThreadId. Этот обратный вызов (переданный в качестве делегата в поток) удаляет идентификатор потока из словаря, запускает другой поток из очереди и обновляет пользовательский интерфейс.

Когда и очередь, и словарь пусты, вы закончили.

Немного сложнее, но таким образом вы получаете отзывчивый интерфейс, вы можете легко контролировать количество активных потоков, и вы можете видеть, что в полете. Собирайте статистику. Познакомьтесь с WPF и установите индикаторы выполнения для каждого файла. Она не может не быть впечатлена.