Russian Qt Forum

Создается поток по нажатию и запускается по нажатию кнопки
но почему-то при закрытии виджета поток все еще остается, хотя в
деструкторе я его убиваю.
Подскажите в чем причина  ???

C++ (Qt)
void Widget::createThread()
{
 ...
 thread = new Thread();
 thread->start();
 
} 
 
void Widget::~Widget()
{
  if(thread->isRunning()){
     thread->quit();
     thread->wait();
     thread->deleteLater();
 }
}
 
 

Может потому, что deleteLater() не сразу удаляет обьект.
А как Вы определяете, что он все еще остается?

deleteLater() удалит поток когда:

1. Он перестанет работать.
2. На него никто не будет ссылаться.

Возникает вопрос, что внутри потока ?

по выводу сообщения в консоль из потока через дебаг

C++ (Qt)
void Thread::run()
{
  forever(){
    qDebug()<<"Thread";
    funcWait(20); //20 msec
 }
}
 

Ступил, понял
надо делать так:

C++ (Qt)
void Widget::createThread()
{
 ...
 thread = new Thread();
 thread->threadStart = true;
 thread->start();
 
} 
 
void Widget::~Widget()
{
  if(thread != NULL){
     thread->startThread = false
     thread->quit();
     thread->wait();
     thread->deleteLater();
 
void Thread::run(){
 
  forever(){
  if(!threadStart){
    break;
  }
 ...
}
 

А почему deleteLater()? Обычный delete() чем плох?

Не знаю как можно сослаться на поток, прошу привести пример. И по-моему если поток и работает - все равно удалится (некорректно, ошибка в консоли).

deleteLater засылает событие на удаление в текущий EventLoop, удаление будет выполнено когда дело дойдет до этого события. Это иногда удобно, но операция опасная, не надо использовать ее без необходимости.

Операция с тем же риском, что и new и delete. Если не изгаляться и думать при написании об архитектуре, то всё будет нормально.

Тогда поясните что должно происходить в примере выше

C++ (Qt)
 if(thread != NULL){
     thread->startThread = false
     thread->quit();
     thread->wait();
     thread->deleteLater();

- в какой (или чей) EventLoop будет помещено событие удаления?
- когда оно будет извлечено и произойдет удаление thread?

А вы готовы утверждать в чей eventloop попадет событие по тем отрывкам кода, который есть в теме?
Очень интересно. :)

так как правильно ???
или

В вашем случае достаточно простого delete.

А чего мне утверждать - я лучше спрошу у того кто делает такие авторитетные заявления
Пусть он разъясняет/утверждает  :)

Вы задаете вопросы, для ответов на которые не хватает информации и просите разяснить или утвердить? :)

Ну что Вы, право, как орел защищающий птенца-Вереса :) Нечего его защищать, как всегда ляпнул не подумавши - пусть отвечает. А для Вас я запостил тему про темплейты, лучше там ответьте

EventLoop будет Widget. Так что спокойно встанет, дождётся выключения потока и успешно удалится.

Я саму разберусь, в какой теме мне отвечать, а в какой нет.

И сам решу, кого мне защищать, а кого нет. К тому же я никого не защищаю, скорее по этому вопросу думаю также.
Это вы ваши сложности с deleteLater и вообще с очередями сообщений, пытаетесь представить вселенской опасностью. А она яйца выеденного не стоит, если понимать, что делаешь.А по другому, лучше ничего не делать.

А если объект класса Thread делает moveToThread?

Неверно (по крайней мере в общем случае)
Тоже неверно, никто никого дожидаться не будет

Как раз в общем случае верно, объект QThread будет принадлежать создающей его нитке, а не порождаемой им.

Тут не знаю про что вы говорите. :)

Так это называется "по умолчанию" и к общности отношения не имеет.

Просто когда дело дойдет до события DeferredDelete (порожденного deleteLater), то объект удалится невзирая на  "незавершенный поток".

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

C++ (Qt)
if(thread != NULL){
     thread->startThread = false
     thread->quit();
     thread->wait();
     thread->deleteLater();

Вы совершенно правильно указали что без контекста невозможно предсказать поведение deleteLater. Весьма вероятно где-то выше понадобится

C++ (Qt)
thread->moveToThread(thread)

Иначе какой смысл крутить там EventLoop? Но тогда событие DeferredDelete будет помещено в очередь thread - но она уже остановлена (thread->quit()). Когда же удалится  thread? Наверное никогда (без доп действий). Почему "наверное" - ну хз, может у Qt есть доп процессинг для этого случая (вряд ли, но не проверял).

Спрашивается: а за каким <template> было так делать, искать ненужных приключений? Чем было плохо простецкое delete? Зачем надо было продлевать жизнь thread? Что хотели еще от нее получить? Это называется "понимать что делаешь"? Совсем наоборот. Тоже мне, сокол защищающий выеденные яйца  :)

Смешались в кучу кони люди... :) Ну да ладно.

Igors в общем случае поведение будет согласно моему сообщению. А вот перенос QThread moveToThread как раз отдельный случай.

Зачем ждать? потому что поток может быть занят вычислениями. Ему пофиг что там кто-то где-то приказал завершаться :) И он будет заканчивать заданную ему работу. Именно на этот случай и сделан Wait, дающий ему время на корректное и заложенное по умолчанию завершение.

И да, deleteLater тут возможно избыточен, но тем не менее он сработает и будет всё хорошо :)

И скорее всего ситуация с вызовом deleteLater из собственного потока обрабатывается Qt. Ибо ни разу не имел с deleteLater утечек памяти.

PS попадал однажды в похожую ситуацию с потоками, но давно. К сожалению найти исходников не смог.

Никто никого не ждет - сказали удалить QThread - и этот объект будет удален, занимаемая им память станет доступной для других. Если поток (порожденный этой QThread) еще работает (используя удаленные данные) - ну вылетит, c'est la vie

Ничего он не дает и никаких умолчаний нет. Это просто останов текущей нитки до тех пор пока указанная не завершится - и все (см pthread_join). Если указанная не собирается завершаться  - текущая ждет forever