Блог

У меня странная проблема:

В моем приложении C # я создаю другой поток, вот так:

 Thread printThread = new Thread(printWorker);

printThread.Name = "Logger MainThread";
printThread.IsBackground = true;
printThread.Start();
  

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

Каковы могут быть причины этого? Этот объект содержит объект Mutex, не уверен, что это может быть причиной…

У кого-нибудь есть идеи?

Вот код из метода printWorker:

 while (loggerIsActive)
{
    LogMessage log = LoggerQueue.Dequeue();

    if (log.message != null)
    {
        syncLogObj.WaitOne();
        lock (writerobj)
        {
            StreamWriter sw;

            if (!File.Exists(fName))
            {
                sw = File.CreateText(fName);
            }
            else
            {
                sw = new StreamWriter(fName, true);
            }

            using (sw)
            {
                if (log.message != "")
                {
                    if (log.message.EndsWith("rn"))
                    {
                        log.message =
                            log.message.Substring(0, log.message.Length - 2);
                    }

                    sw.WriteLine(string.Format("[{0}][{3}][{1}] | {2}",
                                               log.msgTime,
                                               log.level.ToString(),
                                               log.message,
                                               log.sender.ToString()));
                }

                sw.Flush();
                sw.Close();
            }
        }

        syncLogObj.ReleaseMutex();
    }

    Thread.Sleep(5);
}
  

Попробуйте это:

Запустите приложение через VS и завершите работу в обычном режиме. VS должен оставаться в режиме отладки, как вы описали. Нажмите на кнопку паузы (прервать все), а затем перейдите в раздел Отладка-> Windows-> Потоки. Видите ли вы свой «Logger MainThread» в списке?

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

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

убейте его.

Не красиво. Но это не TV. Читать дальше:

1) Не уверен, что вы используете его, но, похоже, вам следует заблокировать loggerqueue перед тем, как ставить в очередь (основной pgm) или удалять из очереди (поток).
2) Нет необходимости блокировать writerobj только с помощью этой настройки. Но на самом деле вы должны, чтобы вы могли безопасно прервать поток не во время записи:

• основной поток:
  • делайте все
  • перед закрытием: -заблокировать writerobj -printthread.прервать
• рабочий поток:
  • добавьте try catch для обработки исключения threadabort и просто завершите работу

Если вы правильно это делаете, вам не нужно использовать ожидания и мьютексы. Если вы используете wait должным образом, вам все равно не понадобится режим ожидания.

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

Но бывают редкие случаи, когда это может быть неправильно. Entonces……

Общий совет, чтобы потоки хорошо справлялись с этой проблемой:

• Основная программа
  • инкапсулировать ведение журнала (в частности, флаг завершения, очередь и ссылку на рабочий поток) в объекте
  • Ведение журнала «глобальные снобы?» — редкий повод использовать одноэлементный шаблон.
  • запустите рабочий поток в объекте logger с помощью метода
  • основной поток всегда вызывает один метод в объекте logger для регистрации ошибки
  • Этот метод блокирует очередь и добавляет к ней.
  • Используйте Monitor / Pulse / Wait, без ожидания; полно примеров предостаточно; это стоит изучить
    • поскольку только этот поток в любом случае обращается к файлу, если у вас нет нескольких процессов, вам не нужен waitone / releasemutex.
  • Этот метод ведения журнала monitor.передает объект
  • Это освобождает монитор рабочего потока.ожидание (которое переводит процессор в режим ожидания вместо режима ожидания)
  • заблокируйте очередь, только внутри блокировки удалите объект из очереди на локальную ссылку; больше ничего.
  • Выполните свой обычный код протоколирования и цикл проверки выхода. Добавить
    • Ваш логический код может оставить сообщение ненаписанным, если очередь заполнена при завершении:
    • измените проверку выхода, чтобы вы могли сделать это без дополнительной блокировки очереди:
      • переместить объявление ссылки на объект в очереди выше while; установить для него значение nothing
      • измените логику в while на ‘loggerisactive или log != null’
  • когда ваш основной поток завершается, в вашем коде выхода:
    • установите флаг завершения
    • переведите объект, который вы используете, в режим ожидания, если он не обрабатывает очередь
    • Поток завершится.

У вас происходит много вещей, которые вы, очевидно, не показываете…

Пример: у вас есть syncLogObj.WaitOne(); , но мы не видим, где syncLogObj объявляется или используется в другом месте вашей программы.

Кроме того, вам это не нужно… полностью избавьтесь от syncLogObj этой вещи (включая мусор «ReleaseMutex»)… у вас уже есть блокировка (бла) {} , и это все, что вам нужно (из того кода, который вы отобразили).

Вероятно, основной поток НЕ завершается, вероятно, из-за этого или какого-либо другого объекта, который поддерживает его открытым.

Итак, простые инструкции

1. Избавьтесь от syncLogObj (потому что у вас уже есть «блокировка»)
2. Убедитесь, что вы где-то установили loggerIsActive = false .

Редактировать: Еще больше деталей!

Из того, что я вижу — вам вообще не нужен lock (writerobj) , потому что (я совершенно уверен), похоже, у вас есть только один поток, который записывает данные в журнал.

«Блокировка» существует только в том случае, если у вас есть два или более потоков, которые выполняют этот код (в основном).

Если printworker не завершится до завершения вашего основного потока, то основной поток умрет, а ваш printworker поток будет уничтожен операционной системой. Если вы хотите, чтобы main ожидал созданный вами поток, тогда вам следует вызвать printThread.Join() в main . Это заставит main ждать вашего потока.

Когда основной завершится, ваша программа умрет, а ваша printThread будет уничтожена ОС, она не будет продолжать работать.

Отсюда

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

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

 printThread.Join(1000);
if(printThread!=null amp;amp; printThread.IsAlive)
    printThread.Abort();
  

 Thread.Abort();
Thread.Dispose();
  

Это должно сработать, если я не ошибаюсь.