Использование ThreadPool.QueueUserWorkItem - нить неожиданно завершает работу

Question

У меня есть следующий метод:

public void PutFile(string ID, Stream content) 
    { 
     try 
     { 
      ThreadPool.QueueUserWorkItem(o => putFileWorker(ID, content)); 
     } 

     catch (Exception ex) 
     { 
      OnPutFileError(this, new ExceptionEventArgs { Exception = ex }); 
     } 
    } 

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

private void putFileWorker(string ID, Stream content) 
    { 
     //Get bucket name: 
     var bucketName = getBucketName(ID) 
      .ToLower(); 

     //get file key 
     var fileKey = getFileKey(ID); 

     try 
     { 
      //if the bucket doesn't exist, create it 
      if (!Amazon.S3.Util.AmazonS3Util.DoesS3BucketExist(bucketName, s3client)) 
       s3client.PutBucket(new PutBucketRequest { BucketName = bucketName, BucketRegion = S3Region.EU }); 

      PutObjectRequest request = new PutObjectRequest(); 
      request.WithBucketName(bucketName) 
       .WithKey(fileKey) 
       .WithInputStream(content); 

      S3Response response = s3client.PutObject(request); 
      var xx = response.Headers; 

      OnPutFileCompleted(this, new ValueEventArgs { Value = ID }); 
     } 

     catch (Exception e) 
     { 
      OnPutFileError(this, new ExceptionEventArgs { Exception = e }); 
     } 
    } 

Я создал небольшую консоль приложение, чтобы проверить это. Я подключаю обработчики событий для событий OnPutFileError и OnPutFileCompleted.

Если я вызываю свой метод PutFile и вступаю в это, он переходит к строке «// если строка не существует, создайте ее», а затем завершается. Никаких исключений, ошибок нет, ничего. Он не завершается (я также установил точки останова на своих обработчиках событий) - он просто выходит.

Если я запускаю тот же метод без ThreadPool.QueueUserWorkItem, то он работает отлично ...

ли я что-то отсутствует?

Answer 1

ThreadPool нити являются фоновыми потоками (см. Ссылку). Они не будут запускать ваше приложение, если основной поток выйдет.

Как правило, в приложениях WinForms это не проблема, потому что основной поток пользовательского интерфейса вызывает Application.Run и начинает обработку событий. Для вашего консольного приложения, если ваш основной метод не дождался завершения рабочего элемента, основной поток будет стоять в очереди на рабочий элемент и затем выйти.

Вы можете создать фоновый поток самостоятельно и установить его свойство IsBackground в значение false. Или вы можете создать поток и позвонить Thread.Join, чтобы дождаться его завершения.

- EDIT -

Как указывается в комментариях ниже, вы можете также использовать ManualResetEvent, или даже пользовательский класс синхронизации в соответствии с предложением Линик. Цель состоит в том, чтобы заблокировать основной поток до тех пор, пока потоки фона не будут завершены.

Чтобы использовать ManualResetEvent, создайте его в своем основном потоке и передайте его в качестве аргумента. (Я поручу его статической переменной здесь только для краткости.)

ManualResetEvent s_WaitEvent; 

ManualResetEvent s_WaitEvent = new ManualResetEvent(false); // non-signaled 
// queue work item here 
s_WaitEvent.WaitOne(); 

В конце вашего рабочего потока, сигнализируют событие: CountDownLatch

s_WaitEvent.Set(); 

Линка хорошо, если у вас есть много потоки, которые должны обрабатываться, прежде чем вы сможете выйти. Вы также можете использовать отдельные ManualResetEvents для каждого потока и ждать, пока все они будут выполнены, используя WaitHandle.WaitAll(WaitHandle[]). (ManualResetEvent наследуется от WaitHandle.)

Answer 2

Поместите Console.ReadLine() в свой Основной поток, чтобы заблокировать его, пока вы тестируете свою рабочую нить. Это позволит сохранить основной выход. Просто нажмите «Ввод», когда закончите.

Answer 3

Используйте CountDownLatch, чтобы заставить основные ждать все потоков, которые вы выстраивались в очередь:

public class CountDownLatch 
{ 
    private int m_remain; 
    private EventWaitHandle m_event; 

    public CountDownLatch (int count) 
    { 
     if (count < 0) 
      throw new ArgumentOutOfRangeException(); 
     m_remain = count; 
     m_event = new ManualResetEvent(false); 
     if (m_remain == 0) 
     { 
      m_event.Set(); 
     } 
    } 

    public void Signal() 
    { 
     // The last thread to signal also sets the event. 
     if (Interlocked.Decrement(ref m_remain) == 0) 
      m_event.Set(); 
    } 

    public void Wait() 
    { 
     m_event.WaitOne(); 
    } 
} 

В Main:

static void Main(string[] args) 
{ 
    CountDownLatch latch = new CountDownLatch(numFiles); 
    // 
    // ... 
    // 
    putFileWorker("blah", streamContent); 
    // 
    // ... 
    // 

    // waits for all of the threads to signal 
    latch.Wait(); 
} 

В методе работника:

private void putFileWorker(string ID, Stream content) 
{ 
    try 
    { 
     //Get bucket name: 
     var bucketName = getBucketName(ID) 
      .ToLower(); 

     //get file key 
     var fileKey = getFileKey(ID); 

     try 
     { 
      //if the bucket doesn't exist, create it 
      if (!Amazon.S3.Util.AmazonS3Util.DoesS3BucketExist(bucketName, s3client)) 
       s3client.PutBucket(new PutBucketRequest { BucketName = bucketName, BucketRegion = S3Region.EU }); 

      // 
      // ... 
      // 
     } 

     catch (Exception e) 
     { 
      OnPutFileError(this, new ExceptionEventArgs { Exception = e }); 
     } 
    } 
    finally 
    { 
     latch.Signal(); 
    } 
}