QT 4.3在线程之间传递类指针

Question

I am using QT 4.3.1 (Legacy code have to use it) and I am passing a class reference between my worker thread and the GUI thread using signals and slots.

Does QT perform atomic operations on this class if it is composed of native types (Qstring, int, unsigned char), or do I still need a QMutex? Does passing a reference of the class or data buffer between threads safe, or is there a better way to share it and prevent concurrent access?

I have class, COMinfo made from another class and a struct using native types:

typedef struct Port_Check_Struct
{

    U_BYTE  command       :4;
    U_BYTE  spare15_4   :2; /* spare bits */
    U_BYTE  status       :2; 

} PORT_CHECK_STRUCT;


class PortInfo
{
public:

    PortInfo();

    QString     portName;
    U_BYTE      Dir;
    UNSIGNED16  Addr;
    U_BYTE      Size;

    bool        active;
    U_BYTE      lastused;
    U_BYTE      currused;
    U_BYTE      errorCntr;

    U_BYTE      portBuff[100];
    U_BYTE      dataBuff[100];

    PORT_CHECK_STRUCT   *portCheck;
};


class COMInfo
{
public:
    UNSIGNED8   errorStatus;

    UNSIGNED16  COMaddr;

    PortInfo    portInfo[4];
};

    // Define Meta Types for SIGNAL/SLOT CROSS THREAD TYPES
    qRegisterMetaType<COMInfo>("COMInfo");

I registered the data type to the MOC with qRegisterMetaType().

I am passing references between my worker thread and the GUI thread like so:

emit COM_DATA_UPDATE(COM_Info.portInfo[0].dataBuff)

What does QT with this reference? Is it a shallow copy? Need a copy constructor?

The signal is defined as:

void   COM_DATA_UPDATE(const U_BYTE* msg);

Also have a signal I pass the actual const class reference:

void   INFO_UPDATE(const COMInfo& comInfo);

Answer 1

"Does QT perform atomic operations on this class if it is composed of native types" - the language is C++, Qt just a library. Thus Qt doesn't do any magic when variables are accessed from multiple threads and the usual C++ multithreading rules and its memory model (since C++11) apply. The signal/slot mechanism however implements a message passing mechanism for inter-thread communication: Queued connections (see also the page on thread synchronisation ) pass the arguments from one thread to another by copying them. Ie, passing value types such as QString, int, double is safe - the receiving thread will operate on a copy of the sending thread's data and there's no concurrent access that'd need locking. Signal/Slot arguments passed by const reference will also be copied by the signal/slot system.

However, if you pass pointers either as argument or contained in a struct, the pointer is copied , not the object it points to (in the case there's no custom copy ctor/assignment operator implementation doing otherwise). Thus, accessing the passed pointer is not safe for the and you'd need a synchronisation mechanism such as a mutex.

In your example, PORT_CHECK_STRUCT *portCheck has this problem (when passing a PortInfo object), as well as void COM_DATA_UPDATE(const U_BYTE* msg) . I'd suggest to pass the data via std::array (or std::vector/QVector if you can't use C++11).