pultarecnoaterdi.netlify.com

Lets explain it more, Each thread created by Qt (including main thread and new threads created by QThread) have Event loop, the event loop is responsible for receiving signals and call aproporiate slots in its thread. Warns for any slot present in QThread derived classes. Although not necessarily a bug, it’s usually a code smell, as these slots will run in the thread where the QThread QObject lives and not in the thread itself. The best practice is usually to use worker objects, as illustrated here.

Multithreaded programming is also a useful paradigm for performing time-consuming operations without freezing the user interface of an application.

1. The signal timeout emitted from main thread, As timer and worker live in different threads, their connection type is queued connection. The slot get called in its living thread, which is the sub-thread. Thanks to a mechanism called queued connections, it is safe to connect signals and slots across different threads.
2. I assume that you are using the same object through pointers in different threads. Then this might be possible. However, the signal-slot mimic will more or less generate a direct function call which will be executed in the thread you are emitting the signal. I do not see a way to tell the thread that it has to execute the function in another thread.
3. Qt Signals And Slots Across Threads are given a 100% deposit bonus, you will actually receive €/£/$1,000 in your account. This gambling bonus usually only applies to the initial deposit Qt Signals And Slots Across Threads you make, so do check if you are eligible before you put money in. Most casinos also offer free spins and no deposit.

QThread is the easy-to-use class in Qt allow user to implement things in a sperated thread.
'As of Qt4, you can use

Qt Signal Thread

QThread to start your own event loops. This might sound somewhat uninteresting at first, but it means you can have your own signals and slots outside the main thread.'
In GUI applications, the main thread is also called the GUI thread because it's the only thread that is allowed to perform GUI-related operations. You can implement, for instance, of a algorithm executed in a blocking way, into a sperated thread. Therefore, your GUI will not be frozen during the execution of algorithm. Then connect the main thread and algorithm thread by signal and slots. Namely, you can now emit a signal in one thread and receive it in a slot in a different thread.
The following is a simple example, in which a second-timer is wrapped in a QThread and a QWidget in main thread can start and stop the timer in any time.
//-----------------------------
CookingClock.cpp in timer thread
//-----------------------------

CookingClock::CookingClock(QObject *parent )
:QThread( parent)
,iSeconds_(10)
,iSecondsAccu_(0)
{
timer_.setInterval(1000); //second timer
connect( &timer_, SIGNAL(timeout()), this, SLOT(countSeconds()));
QThread::start();
}
void CookingClock::run()
{
exec();
}
void CookingClock::countSeconds()
{
iSecondsAccu_++;
emit( secondTicked(iSeconds_ - iSecondsAccu_));
if(iSecondsAccu_>=iSeconds_)
{
emit( timeIsUp());
timer_.stop();
}
}
void CookingClock::stop()
{
if(timer_.isActive())
{
timer_.stop();
}
}
void CookingClock::start()
{
iSecondsAccu_ = 0;
timer_.start();
}

//-----------------------------
CookingClockWidget.cpp in main thread
//-----------------------------

Qt Signal Slot Different Threads


CookingClockWidget::CookingClockWidget(QWidget *parent)
:QWidget(parent)
, clock_(0)
{
clock_ = new CookingClock_v2();
QPushButton* pButtonStart = new QPushButton('start');
QPushButton* pButtonStop = new QPushButton('stop');
connect( pButtonStart, SIGNAL(clicked()), clock_, SLOT(start()));
connect( pButtonStop, SIGNAL(clicked()), clock_, SLOT(stop()));
connect( clock_, SIGNAL(secondTicked(int)), this, SLOT(print(int)));
QHBoxLayout* pLayout = new QHBoxLayout;
pLayout->addWidget(pButtonStart);
pLayout->addWidget(pButtonStop);
setLayout(pLayout);
}
void CookingClockWidget::print( int second)
{
qDebug('second : %d', second);
}

Reference: