Thread.Join принудительно закрывает нить на конце приложения

Question

У меня есть класс, который реализует IDisposable. Класс содержит нить и нить закрыта в методе Dispose с помощью Thread.Join(...)

Мой вопрос, однако, что если я бегу моего класса, как это:

static void Main(string[] args) 
{ 
    var class = new MyClass(); 
    class.Run(); 
} 

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

Однако, если я бегу это так:

static void Main(string[] args) 
{ 
    using (var class = new MyClass()) 
    { 
     class.Run(); 
    } 
} 

нить заканчивает то, что она начала и заканчивается изящно. Что такое оператор using, который позволяет потоку завершить выполнение?

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

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

Edit:

~ElasticBase() 
{ 
    Dispose(false); 
} 

public virtual void Initialize() 
{ 
    workerThread = new Thread(ProcessData) 
    { 
     Name = "ElasticBase thread", 
     IsBackground = true 
    }; 

    IsInitialized = true; 
} 

public virtual void Shutdown() 
{ 
    if (workerThread.IsAlive) 
    { 
     IsInitialized = false; 
     lock (syncObject) 
     { 
      if (!workerThread.Join(10000)) 
      { 
       workerThread.Abort(); 
      } 
      workerThread = null; 
     } 
    } 
} 

public void Dispose() 
{ 
    Dispose(true); 
    GC.SuppressFinalize(this); 
} 

protected void Dispose(bool calledFromDispose) 
{ 
    Shutdown(); 
} 

Как вы можете видеть, с указанным кодом. Метод Shutdown вызывается в Dispose. Если я НЕ ВЫПОЛНИТЬ Утилиту явно, и я НЕ использую используемый блок, метод Thread.Join закрывается без завершения. Однако, если я вызываю Dispose explicity или использую блок using, вдруг Thread.Join работает так, как ожидалось. Зачем?

TLDR;

Когда Dispose вызывается через финализатор, Thread.Join не ждет завершения. Когда утилита явно вызывается (посредством ручного вызова ее или с помощью оператора using), Thread.Join ждет завершения.

Answer 1

Вы пропустили две части информации:

• Thread.Join не закрывает поток. Скорее, он ждет, пока поток завершит выполнение.
• using - всего лишь синтаксический сахар для вызова метода Dispose в блоке try/finally.

Чтобы сделать это просто, ваш код эквивалентен:

MyClass class = null; 

try 
{ 
    class = new MyClass(); 
    class.Run(); 
} 
finally 
{ 
    if (class != null) 
    { 
     class.Dispose(); 
    } 
} 

Поскольку ваш метод Dispose вызывает Thread.Join, который, в свою очередь ждет нить для завершения выполнения, приложение не выходит преждевременно.