QT的信号/槽和并行线程不玩好起来

Question

谁能告诉我为什么这个Qt代码不会调用定义ASYNC_TIMERS回调时（即m_timer.start从并行线程调用，但插槽从未运行）。显然，这是从并行线程被调用时做没有定义ASYNC_TIMERS，但我想知道如何从并行线程修复它，因为它的工作原理。我尝试了许多在网上找到的东西，包括moveToThread（），调用线程运行时调用exec（），但我对这个问题没有运气？

干杯

multitimer.h：

#pragma once 

#ifndef MULTI_TIMER_H 
#define MULTI_TIMER_H 

#include <QThread> 
#include <QTimer> 
#include <QMutex> 

#include <QMap> 


#include <QMetaType> 
#include <cassert> 


class MultiTimer : public QThread 
{ 
    Q_OBJECT 

public: 
    typedef void (*multiTimerCallback)(quint32 p_id); 

private: 
    QTimer m_timer; 
    QMutex m_mutex; 
    quint32 m_id; 
    multiTimerCallback m_callback; 
    void KillTimer(void); 

public: 
    // only TimerFactory is allowed to instantiate MultiTimer 
    MultiTimer(quint32 p_id, multiTimerCallback p_callback); 
    ~MultiTimer(); 
    enum TTimerType 
    { 
     TT_SingleShot,  ///< Timer fires only once 
     TT_Repetitive  ///< Timer keeps firing repeatedly until stopped with KillTimer() 
    }; 
    void SetTimer(quint32 p_delayInMilliseconds, MultiTimer::TTimerType timerType); 

private slots: 
    void Update(void); 
}; 

#endif 

timer.cpp：

#include <QtCore/QCoreApplication> 
#include "multitimer.h" 
#include <stdio.h> 


//-------------------------------------------------------------------------------------------------- 

void MultiTimer::SetTimer(quint32 p_delayInMilliseconds, MultiTimer::TTimerType timerType) 
{ 
    QMutexLocker locker(&m_mutex); 

    m_timer.setSingleShot(TT_SingleShot == timerType ? true : false); 
    m_timer.start(p_delayInMilliseconds); 
    //QTimer::singleShot(p_delayInMilliseconds, this,SLOT(Update())); 
} 

void MultiTimer::KillTimer(void) 
{ 
    QMutexLocker locker(&m_mutex); 
    m_timer.stop(); 
} 

void MultiTimer::Update(void) 
{ 
    QMutexLocker locker(&m_mutex); 

    if (NULL != m_callback) 
     m_callback(m_id); 
} 

MultiTimer::MultiTimer(quint32 p_id, multiTimerCallback p_callback) 
    : m_id(p_id) 
    , m_callback(p_callback) 
{ 
    bool isConnected = true; 
    isConnected &= this->connect(&this->m_timer, SIGNAL(timeout()), this, SLOT(Update()), Qt::QueuedConnection); 
    assert(isConnected); 
    //this->start(); 
} 

MultiTimer::~MultiTimer() 
{ 
    KillTimer(); 
    wait(); 
} 


//-------------------------------------------------------------------------------------------------- 
#define ASYNC_TIMERS 
#define GLOBAL_TIMERS 

void Callback(quint32 p_id) 
{ 
    printf("Got timered by timer %d.\n", p_id); 
} 

MultiTimer *mt; 
void StartTimers(void) 
{ 
    #ifndef GLOBAL_TIMERS 
    mt = new MultiTimer(1, Callback); 
    #endif 
    mt->SetTimer(1000, MultiTimer::TT_SingleShot); 
} 

#ifdef ASYNC_TIMERS 
pthread_t AsyncTaskThread; 
void *ProcessAsyncTasks(void */*ptr*/) 
{ 
    StartTimers(); 
    return NULL; 
} 
#endif 

int main(int argc, char *argv[]) 
{ 
    QCoreApplication a(argc, argv); 

    #ifdef GLOBAL_TIMERS 
    mt = new MultiTimer(1, Callback); 
    #endif 

    #ifdef ASYNC_TIMERS 
    pthread_create(&AsyncTaskThread, NULL, &ProcessAsyncTasks, NULL); 
    #else 
    StartTimers(); 
    #endif 

    return a.exec(); 
} 

Answer 1

你需要一个QEventLoop处理信号/槽的东西，在新的线程。

QTimer需要这些工作。

void *ProcessAsyncTasks(void */*ptr*/) 
{  
    QEventLoop loop; 
    StartTimers();  
    loop.exec(); 
    return NULL; 
} 

为什么不使用QThread？

Answer 2

我认为Threads and QObjects了答案：你不能在不同的线程比你创建它在那里使用事件驱动的对象。

在你的代码，如果启用GLOBAL_TIMERS，你会在你的主线程 创建MultiTimer，但在不同的一个叫m_timer.start()。

报价文档：

事件驱动对象可以只在一个单一的线程中使用。具体而言，这适用于定时器机制和网络模块。例如，您不能在不是对象线程的线程中启动计时器或连接套接字。

所以不这样做。 （并使用QThread，而你在它。）

Answer 3

确定任何人也试图解决这个问题，我想我明白了这一点，如果我将m_timer和multitimer对象移回主qt线程并发出定时器启动信号“正常”这一切似乎工作（见下文）。

可能我仍然可以在qthread中调用一个exec来调用pthread，并将multitimer和m_timer移动到那个地方，但这种方式现在可行，而且我得到了“通过定时器％d得到了时间。\ n “输出准时，即使在pthread死后视为需要。：

感谢所有的输入，如果有更好的方法来做到这一点或一个大规模的错误，我忽略了这将是很好的知道吗？干杯

multitimer.h：

/** 
    @file multitimer.h 
    @brief Partial implementation of Windows-like SetTimer()/KillTimer() for Qt. 

*/ 
#pragma once 

#ifndef MULTI_TIMER_H 
#define MULTI_TIMER_H 

#include <QThread> 
#include <QTimer> 
#include <QMutex> 

#include <QMap> 


#include <QMetaType> 
#include <cassert> 


class MultiTimer : public QThread 
{ 
    Q_OBJECT 

public: 
    typedef void (*multiTimerCallback)(quint32 p_id); 

private: 
    QTimer m_timer; 
    QMutex m_mutex; 
    quint32 m_id; 
    multiTimerCallback m_callback; 
    void KillTimer(void); 

public: 
    // only TimerFactory is allowed to instantiate MultiTimer 
    MultiTimer(quint32 p_id, multiTimerCallback p_callback); 
    ~MultiTimer(); 
    enum TTimerType 
    { 
     TT_SingleShot,  ///< Timer fires only once 
     TT_Repetitive  ///< Timer keeps firing repeatedly until stopped with KillTimer() 
    }; 
    void SetTimer(quint32 p_delayInMilliseconds, MultiTimer::TTimerType timerType); 

private slots: 
    void Update(void); 

signals: 
    void start_sig(int); 
}; 

#endif  

timer.cpp：

#include <QtCore/QCoreApplication> 
#include "multitimer.h" 
#include <stdio.h> 


//-------------------------------------------------------------------------------------------------- 

void MultiTimer::SetTimer(quint32 p_delayInMilliseconds, MultiTimer::TTimerType timerType) 
{ 
    QMutexLocker locker(&m_mutex); 
    m_timer.setSingleShot(TT_SingleShot == timerType ? true : false); 
    connect(this, SIGNAL(start_sig(int)), &m_timer, SLOT(start(int)), Qt::QueuedConnection); 
    //m_timer.start(p_delayInMilliseconds); 
    emit start_sig(p_delayInMilliseconds); 
    disconnect(this, SIGNAL(start_sig(int)), &m_timer, SLOT(start(int))); 
} 

void MultiTimer::KillTimer(void) 
{ 
    QMutexLocker locker(&m_mutex); 
    m_timer.stop(); 
} 

void MultiTimer::Update(void) 
{ 
    QMutexLocker locker(&m_mutex); 

    if (NULL != m_callback) 
     m_callback(m_id); 
} 

MultiTimer::MultiTimer(quint32 p_id, multiTimerCallback p_callback) 
    : m_id(p_id) 
    , m_callback(p_callback) 
{ 
    bool isConnected = true; 
    isConnected &= this->connect(&this->m_timer, SIGNAL(timeout()), this, SLOT(Update()), Qt::QueuedConnection); 
    assert(isConnected); 
    //this->start(); 

    moveToThread(qApp->thread()); 
    m_timer.moveToThread(qApp->thread()); 
} 

MultiTimer::~MultiTimer() 
{ 
    KillTimer(); 
    wait(); 
} 


//-------------------------------------------------------------------------------------------------- 
#define ASYNC_TIMERS 
#define xGLOBAL_TIMERS 

void Callback(quint32 p_id) 
{ 
    printf("Got timered by timer %d.\n", p_id); 
} 

MultiTimer *mt; 
void StartTimers(void) 
{ 
    #ifndef GLOBAL_TIMERS 
    mt = new MultiTimer(1, Callback); 
    #endif 
    mt->SetTimer(2000, MultiTimer::TT_SingleShot); 
} 

#ifdef ASYNC_TIMERS 
pthread_t AsyncTaskThread; 
void *ProcessAsyncTasks(void */*ptr*/) 
{ 
    StartTimers(); 
    return NULL; 
} 
#endif 

int main(int argc, char *argv[]) 
{ 
    QCoreApplication a(argc, argv); 

    #ifdef GLOBAL_TIMERS 
    mt = new MultiTimer(1, Callback); 
    #endif 

    #ifdef ASYNC_TIMERS 
    pthread_create(&AsyncTaskThread, NULL, &ProcessAsyncTasks, NULL); 
    #else 
    StartTimers(); 
    #endif 

    return a.exec(); 
}