Terminar indevidamente um encadeamento?
Eu tenho uma simulação de corpo n que estou paralelizando. Estou usando o QT, portanto, tenho uma classe QObject personalizada que possui o processo paralelo. É controlado por outro QObject dentro de um thread que apenas lida com o thread. O problema é que toda vez que um objeto colide com outro, todos os threads precisam ser interrompidos para que possam ser excluídos e recriados com um sistema diferente de planetas.
Aqui está a fonte da classe do manipulador de threads:
#include "threadhandler.h"
#include <QEventLoop>
#include "subprocess.h"
#include <QThread>
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
ThreadHandler::ThreadHandler(double scopeX, double scopeY)
{
int size = 100;
int idealNum = QThread::idealThreadCount();
int sizeForEach = size/idealNum;
for(int i = 0 ; i< idealNum ;i++){
SubProcess* tempSub = new SubProcess(i*sizeForEach, (i+1)*sizeForEach, scopeX, scopeY);
QThread* tempThread = new QThread;
tempSub->moveToThread(tempThread);
QEventLoop::connect(tempSub, SIGNAL(finished()), tempThread, SLOT(deleteLater()));
QEventLoop::connect(tempThread, SIGNAL(started()), tempSub, SLOT(process()));
QEventLoop::connect(tempThread, SIGNAL(finished()), tempSub, SLOT(deleteLater()));
QEventLoop::connect(tempSub, SIGNAL(collided()), this,
SLOT(refactorObjects()));
ThreadHandler::threads.push_back(tempThread);
ThreadHandler::objects.push_back(tempSub);
}
}
void ThreadHandler::process(){
std::cout << ThreadHandler::threads.size() << std::endl;
for(int i = 0; i < ThreadHandler::threads.size(); i++){
std::cout << "starting " << i+1 << std::endl;
ThreadHandler::threads.at(i)->start();
}
}
void ThreadHandler::refactorObjects(){
SubProcess::condition = false;
std::this_thread::sleep_for(std::chrono::seconds(1));
for(int i = 0 ; i < ThreadHandler::threads.size() ; i++){
ThreadHandler::threads.at(i)->terminate();
}
ThreadHandler::objects.clear();
SubProcess::sys.push_back(Body::collide(SubProcess::collidedAr.at(0), SubProcess::collidedAr.at(1)));
SubProcess::sys.erase(std::remove(SubProcess::sys.begin(), SubProcess::sys.end(),
SubProcess::collidedAr.at(0)), SubProcess::sys.end());
SubProcess::sys.erase(std::remove(SubProcess::sys.begin(), SubProcess::sys.end(),
SubProcess::collidedAr.at(1)), SubProcess::sys.end());
int idealNum = QThread::idealThreadCount();
int sizeForEach = SubProcess::sys.size() / idealNum;
for(int i = 0 ; i < idealNum ; i++){
SubProcess* tempSub = new SubProcess(i*sizeForEach, (i+1)*sizeForEach);
tempSub->moveToThread(ThreadHandler::threads.at(i));
ThreadHandler::objects.push_back(tempSub);
QEventLoop::connect(tempSub, SIGNAL(finished()), ThreadHandler::threads.at(i), SLOT(deleteLater()));
QEventLoop::connect(ThreadHandler::threads.at(i), SIGNAL(started()), tempSub, SLOT(process()));
QEventLoop::connect(ThreadHandler::threads.at(i), SIGNAL(finished()), tempSub, SLOT(deleteLater()));
QEventLoop::connect(tempSub, SIGNAL(collided()), this,
SLOT(refactorObjects()));
}
for(int i = 0; i < idealNum; i++){
ThreadHandler::threads.at(i)->start();
}
std::cout << "refactored" << std::endl;
}
Aqui está a fonte do subprocesso:
#include "subprocess.h"
#include <iostream>
std::vector<Body> SubProcess::sys;
std::vector<Body> SubProcess::collidedAr;
double SubProcess::timeScale;
bool SubProcess::condition = true;
SubProcess::SubProcess(double start, double end, double scopeX, double scopeY){
for(int i = start; i< end; i++){
SubProcess::sys.push_back(Body::createRandomBody(scopeX, scopeY));
}
this->start = start;
this->end = end;
}
SubProcess::SubProcess(double start, double end){
this->start = start;
this->end = end;
}
void SubProcess::process(){
while(SubProcess::condition){
for(int i = start; i < end ; i++){
for(int j = 0; j < SubProcess::SubProcess::sys.size() ; j++){
if(!(SubProcess::sys.at(i)==SubProcess::sys.at(j))){
double F = Body::getForce(SubProcess::sys.at(i), SubProcess::sys.at(j));
if (F!=-1){
double dX = SubProcess::sys.at(i).getX()-SubProcess::sys.at(j).getX();
double dY = SubProcess::sys.at(i).getY()-SubProcess::sys.at(j).getY();
SubProcess::sys.at(i).exertForce(-dY, -dX, F, timeScale);
} else {
SubProcess::collidedAr.clear();
SubProcess::collidedAr.push_back(SubProcess::sys.at(i));
SubProcess::collidedAr.push_back(SubProcess::sys.at(j));
SubProcess::condition = false;
emit collided();
}
}
}
SubProcess::sys.at(i).tick(timeScale);
}
}
emit finished();
}
Sempre que eu o executo, ele funciona perfeitamente até o ponto de uma colisão onde eu recebo:
starting 1
starting 2
starting 3
starting 4
refactored
refactored
QThread: Destroyed while thread is still running
QThread: Destroyed while thread is still running
QThread: Destroyed while thread is still running
QThread: Destroyed while thread is still running
Então, o que não faz sentido para mim é que os threads são excluídos no início do processo de refatoração e isso não gera erros. Mas, por alguma razão, APÓS os novos threads serem iniciados, algo está terminando-os. Não tenho ideia do que está acontecendo aqui. Eu acho que estou descartando e recriando incorretamente os threads e que deve haver um método melhor para isso.