Data sharing between threads

[havij000]

Hello everybody,

I am new to the qt an now I am trying to write a multithread program. In this program I need to share specific data between the threads. I define these data in a specific class but as I want each elements of this class I recieved the undifined error.

what should I do?

Thanks

[ChrisW67]

Unless you give us information we cannot help. We have no idea what your code looks like, what the errors are, what you have tried to "fix" it, what this has to do with Qt, what this has to do with threads etc.

[havij000]

Thanks ChrisW67,

first of all I want to know how should I share a specific data such as a data structure or a static array between different threads as a global data. for example I need a buffer which is fill up with one thread and sorted with another thread and showed with a third thread.

[anda_skoa]

You share the data just like you would in a single thread case, e.g. pass by pointer or reference, have a global variable or accessible through a singleton.
The only difference is that you need to protect against concurrent access.

Cheers,
_

P.S.: posting to a three year old thread instead of adding information to your new one is going to annoy people, scatter necessary information, increase the time until your problem can be understood

[havij000]

Dear anda_skoa,

thanks for your reply. I am just sharing like in single thread case, defining a new class and in this class I declear my required data as the class members and by creating objects of this class in different threads, shared the data but I face this (error: undefined reference to `Data_Class:rime_rcv_buff_flag')

this is the class that I share the data with it:

#ifndef DATA_CLASS_H
#define DATA_CLASS_H
 
#include <QObject>
 
 
class Data_Class : public QObject
{
    Q_OBJECT
public:
    explicit Data_Class(QObject *parent = 0);
 
    struct A2D_hdr
    {
        unsigned short PRF_Num;//PRF Number
        unsigned short Frame_Num;//Frame Number
        unsigned short Video_Length;//video packet total length
        unsigned short EOP;//End of packet if all bit set 1
        unsigned long rsrvd;//Reserved
    };
 
    struct DDC_packet
    {
        struct A2D_hdr DDC_HDR;
        unsigned short A2D_Data[700];//1400 byte data
 
    };
 
    struct MAC_Data_HDR
    {
        unsigned short CMD;//command
        unsigned short Base_Addrs;//Base Address
        unsigned short Length;//Length for burst operation in word
    };
 
    struct MAC_Data
    {
        struct MAC_Data_HDR total_HDR;
 
        struct DDC_packet total_data;
 
    };
 
    struct PKT_CMPLT_DATA//*************need to add header to it.
    {
        bool valid;
        bool total_set;
        bool total_modify;
 
        unsigned short arvd_pkts;// for cheking that which has not arrived yet
 
        unsigned short prf_num;
 
        struct MAC_Data_HDR total_header;//hazf shavad
        //struct A2D_hdr cmplt_data_hdr;
 
        unsigned char total_hdr[6];
        unsigned char A2Dhdr[36];
 
        bool part1_set;
        bool part1_modified;
        struct A2D_hdr cmplt_data_hdr_prt_1;
        unsigned short cmplt_data_prt_1[700];//bayad hazf shavad
        unsigned char CmpltData_prt_1[1400];
 
        bool part2_set;
        bool part2_modified;
        struct A2D_hdr cmplt_data_hdr_prt_2;
        unsigned short cmplt_data_prt_2[700];//bayad hazf shavad
        unsigned char CmpltData_prt_2[1400];
 
        bool part3_set;
        bool part3_modified;
        struct A2D_hdr cmplt_data_hdr_prt_3;
        unsigned short cmplt_data_prt_3[700];//bayad hazf shavad
        unsigned char CmpltData_prt_3[1400];
 
        bool part4_set;
        bool part4_modified;
        struct A2D_hdr cmplt_data_hdr_prt_4;
        unsigned short cmplt_data_prt_4[700];//bayad hazf shavad
        unsigned char CmpltData_prt_4[1400];
 
        bool part5_set;
        bool part5_modified;
        struct A2D_hdr cmplt_data_hdr_prt_5;
        unsigned short cmplt_data_prt_5[700];//bayad hazf shavad
        unsigned char CmpltData_prt_5[1400];
 
        bool part6_set;
        bool part6_modified;
        struct A2D_hdr cmplt_data_hdr_prt_6;
        unsigned short cmplt_data_prt_6[700];//bayad hazf shavad
        unsigned char CmpltData_prt_6[1400];
 
        bool part7_set;
        bool part7_modified;
        struct A2D_hdr cmplt_data_hdr_prt_7;
        unsigned short cmplt_data_prt_7[700];//bayad hazf shavad
        unsigned char CmpltData_prt_7[1400];
 
    };
 
 
    struct eth_Header
    {
        unsigned char dest_addr[6];
        unsigned char src_addr[6];
        unsigned short lng;
 
        struct MAC_Data data;
    };
 
    //data structure for saving DDC_1 data
       static PKT_CMPLT_DATA Q_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA I_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA Ramp_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA Rare_smpl_pckt_ddc_1[4];
 
    //data structure for saving DDC_2 data
       static PKT_CMPLT_DATA Q_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA I_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA Ramp_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA Rare_smpl_pckt_ddc_2[4];
 
    //data structure for sending requsts
 
    static eth_Header rqst_pkt;
 
    static unsigned char prime_rcv_buff[20][1514];
    static bool prime_rcv_buff_flag[20];
 
 
signals:
 
public slots:
 
};
 
#endif // DATA_CLASS_H

#ifndef DATA_CLASS_H
#define DATA_CLASS_H

#include <QObject>


class Data_Class : public QObject
{
    Q_OBJECT
public:
    explicit Data_Class(QObject *parent = 0);

    struct A2D_hdr
    {
        unsigned short PRF_Num;//PRF Number
        unsigned short Frame_Num;//Frame Number
        unsigned short Video_Length;//video packet total length
        unsigned short EOP;//End of packet if all bit set 1
        unsigned long rsrvd;//Reserved
    };

    struct DDC_packet
    {
        struct A2D_hdr DDC_HDR;
        unsigned short A2D_Data[700];//1400 byte data

    };

    struct MAC_Data_HDR
    {
        unsigned short CMD;//command
        unsigned short Base_Addrs;//Base Address
        unsigned short Length;//Length for burst operation in word
    };

    struct MAC_Data
    {
        struct MAC_Data_HDR total_HDR;

        struct DDC_packet total_data;

    };

    struct PKT_CMPLT_DATA//*************need to add header to it.
    {
        bool valid;
        bool total_set;
        bool total_modify;

        unsigned short arvd_pkts;// for cheking that which has not arrived yet

        unsigned short prf_num;

        struct MAC_Data_HDR total_header;//hazf shavad
        //struct A2D_hdr cmplt_data_hdr;

        unsigned char total_hdr[6];
        unsigned char A2Dhdr[36];

        bool part1_set;
        bool part1_modified;
        struct A2D_hdr cmplt_data_hdr_prt_1;
        unsigned short cmplt_data_prt_1[700];//bayad hazf shavad
        unsigned char CmpltData_prt_1[1400];

        bool part2_set;
        bool part2_modified;
        struct A2D_hdr cmplt_data_hdr_prt_2;
        unsigned short cmplt_data_prt_2[700];//bayad hazf shavad
        unsigned char CmpltData_prt_2[1400];

        bool part3_set;
        bool part3_modified;
        struct A2D_hdr cmplt_data_hdr_prt_3;
        unsigned short cmplt_data_prt_3[700];//bayad hazf shavad
        unsigned char CmpltData_prt_3[1400];

        bool part4_set;
        bool part4_modified;
        struct A2D_hdr cmplt_data_hdr_prt_4;
        unsigned short cmplt_data_prt_4[700];//bayad hazf shavad
        unsigned char CmpltData_prt_4[1400];

        bool part5_set;
        bool part5_modified;
        struct A2D_hdr cmplt_data_hdr_prt_5;
        unsigned short cmplt_data_prt_5[700];//bayad hazf shavad
        unsigned char CmpltData_prt_5[1400];

        bool part6_set;
        bool part6_modified;
        struct A2D_hdr cmplt_data_hdr_prt_6;
        unsigned short cmplt_data_prt_6[700];//bayad hazf shavad
        unsigned char CmpltData_prt_6[1400];

        bool part7_set;
        bool part7_modified;
        struct A2D_hdr cmplt_data_hdr_prt_7;
        unsigned short cmplt_data_prt_7[700];//bayad hazf shavad
        unsigned char CmpltData_prt_7[1400];

    };


    struct eth_Header
    {
        unsigned char dest_addr[6];
        unsigned char src_addr[6];
        unsigned short lng;

        struct MAC_Data data;
    };

    //data structure for saving DDC_1 data
       static PKT_CMPLT_DATA Q_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA I_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA Ramp_smpl_pckt_ddc_1[4];
       static PKT_CMPLT_DATA Rare_smpl_pckt_ddc_1[4];

    //data structure for saving DDC_2 data
       static PKT_CMPLT_DATA Q_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA I_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA Ramp_smpl_pckt_ddc_2[4];
       static PKT_CMPLT_DATA Rare_smpl_pckt_ddc_2[4];

    //data structure for sending requsts

    static eth_Header rqst_pkt;

    static unsigned char prime_rcv_buff[20][1514];
    static bool prime_rcv_buff_flag[20];

    
signals:
    
public slots:
    
};

#endif // DATA_CLASS_H

To copy to clipboard, switch view to plain text mode 

and use it in other threads as below in the header of the thread

Data_Class *data_rcv_child;

Data_Class *data_rcv_child;

To copy to clipboard, switch view to plain text mode 

and in the .cpp of the thread:

Recive_Thread::Recive_Thread(QObject *parent) :
    QThread(parent)
{
 
    data_rcv_child = new Data_Class(this);
}
 
 
void Recive_Thread::run()
{
 
    while(true)
    {
        .
        .
        .
        memcpy(&data_rcv_child->prime_rcv_buff + prime_rcv_counter, buffer,sizeof(buffer));
 
        data_rcv_child->prime_rcv_buff_flag[prime_rcv_counter] = true;
 
       .
       .
 
 
    }
}

Recive_Thread::Recive_Thread(QObject *parent) :
    QThread(parent)
{
    
    data_rcv_child = new Data_Class(this);
}


void Recive_Thread::run()
{

    while(true)
    {
        .
        .
        .
        memcpy(&data_rcv_child->prime_rcv_buff + prime_rcv_counter, buffer,sizeof(buffer));

        data_rcv_child->prime_rcv_buff_flag[prime_rcv_counter] = true;

       .
       .
       

    }
}

To copy to clipboard, switch view to plain text mode 

and face the error that I mentioned above

[ChrisW67]

You have declared that a static array of bools exists. Where and how have you defined that array?

I really don't think you understand what the storage type of "static" is doing.

[havij000]

I defined the static bool array in class Data_Class header. Am I wrong here?

As I have to check its value in other threads, I declear static type, thus the array keep its last change and I can check it in other threads.

[ChrisW67]

No, you declared the array in the Data_Class header. You have declared the static therefore there is only one array shared between all objects of that class (regardless of thread or whether objects of that class exist). Space for the static array is not allocated by creating new instances of Data_Class objects. A cpp source file needs to define the static variable and provide somewhere for the single array to be stored so the linker can connect every attempt to use it to that storage.

If you are expecting a separate array for each thread then you certainly do not want "static" members.

This has nothing to do with threads or Qt: it is C++.

[havij000]

no I dont want separate array for each thread. the data is the same for all of them and each thread should do one part of the operation on these data.

My main problem here is that when I want to use any field of the class in each thread I face a the undifine error.
I need to know the how is the exact way of data sharing between threads?

[ChrisW67]

My main problem here is that when I want to use any field of the class in each thread I face a the undifine error.

Yes, and I have already told you what you need to do to fix it: define the storage for the array.
In the header

class Stuff {
public:
  static bool thingies[10];  // this is a declaration that a static array exists.
};

class Stuff {
public:
  static bool thingies[10];  // this is a declaration that a static array exists.
};

To copy to clipboard, switch view to plain text mode 

in a cpp file:

bool Stuff::thingies[10];  // this defines where the storage for the static array exists.

bool Stuff::thingies[10];  // this defines where the storage for the static array exists.

To copy to clipboard, switch view to plain text mode 

The static storage class has nothing to do with whether the array is accessible from one or more threads and is unnecessary.

I offer a complete example of a multi threaded Qt program sharing data between threads in the hope of dragging this thread into some relevance to Qt:

#include <QCoreApplication>
#include <QTimer>
#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QDebug>
 
 
struct Data {
    Data(): mutex(new QMutex), value(0) { }
    ~Data() { delete mutex; }
 
    QMutex *mutex;
    int value;
};
 
 
class Writer: public QObject
{
    Q_OBJECT
    Data *d;
public:
    Writer(Data *data, QObject *p = 0): 
        QObject(p),
        d(data)
    { }
signals:
    void finished();
public slots:
    void process() {
        QTimer *timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), SLOT(tick()));
        timer->setInterval(1000);
        timer->start();
 
        QTimer::singleShot(8000, this, SIGNAL(finished()));    // self-destruct in 8 secs
    }
 
    void tick() {
        qDebug() << "Try writing";
        QMutexLocker locker(d->mutex);
        d->value++;
        qDebug() << "Written" << d->value;
    }
};
 
class Reader: public QObject
{
    Q_OBJECT
    int n;
    Data *d;
public:
    Reader(int number, Data *data, QObject *p = 0): 
        QObject(p),
        n(number),
        d(data)
    { }
signals:
    void finished();
public slots:
    void process() {
        QTimer *timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), SLOT(tick()));
        timer->setInterval(1000);
        timer->start();
 
        QTimer::singleShot(10000, this, SIGNAL(finished()));    // self-destruct in 10 secs
    }
 
    void tick() {
        qDebug() << n << "Try reading";
        QMutexLocker locker(d->mutex);
        qDebug() << n << "Read" << d->value;
    }
};
 
int main(int argc, char **argv) 
{
    QCoreApplication app(argc, argv);
 
    Data data;  // the shared data
 
    QThread* thread = new QThread(qApp);
    Writer* writer = new Writer(&data);
    writer->moveToThread(thread);
    QObject::connect(thread, SIGNAL(started()),  writer, SLOT(process()));
    QObject::connect(writer, SIGNAL(finished()), thread, SLOT(quit()));
    QObject::connect(writer, SIGNAL(finished()), writer, SLOT(deleteLater()));
    QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();
 
    for (int n = 0; n < 3; ++n) {
        thread = new QThread(qApp);
        Reader* reader = new Reader(n, &data);
        reader->moveToThread(thread);
        QObject::connect(thread, SIGNAL(started()),  reader, SLOT(process()));
        QObject::connect(reader, SIGNAL(finished()), thread, SLOT(quit()));
        QObject::connect(reader, SIGNAL(finished()), reader, SLOT(deleteLater()));
        QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
        thread->start();
    }
 
    return app.exec();
}
#include "main.moc"

#include <QCoreApplication>
#include <QTimer>
#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QDebug>


struct Data {
    Data(): mutex(new QMutex), value(0) { }
    ~Data() { delete mutex; }

    QMutex *mutex;
    int value;
};


class Writer: public QObject
{
    Q_OBJECT
    Data *d;
public:
    Writer(Data *data, QObject *p = 0): 
        QObject(p),
        d(data)
    { }
signals:
    void finished();
public slots:
    void process() {
        QTimer *timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), SLOT(tick()));
        timer->setInterval(1000);
        timer->start();

        QTimer::singleShot(8000, this, SIGNAL(finished()));    // self-destruct in 8 secs
    }

    void tick() {
        qDebug() << "Try writing";
        QMutexLocker locker(d->mutex);
        d->value++;
        qDebug() << "Written" << d->value;
    }
};

class Reader: public QObject
{
    Q_OBJECT
    int n;
    Data *d;
public:
    Reader(int number, Data *data, QObject *p = 0): 
        QObject(p),
        n(number),
        d(data)
    { }
signals:
    void finished();
public slots:
    void process() {
        QTimer *timer = new QTimer(this);
        connect(timer, SIGNAL(timeout()), SLOT(tick()));
        timer->setInterval(1000);
        timer->start();

        QTimer::singleShot(10000, this, SIGNAL(finished()));    // self-destruct in 10 secs
    }

    void tick() {
        qDebug() << n << "Try reading";
        QMutexLocker locker(d->mutex);
        qDebug() << n << "Read" << d->value;
    }
};

int main(int argc, char **argv) 
{
    QCoreApplication app(argc, argv);

    Data data;  // the shared data

    QThread* thread = new QThread(qApp);
    Writer* writer = new Writer(&data);
    writer->moveToThread(thread);
    QObject::connect(thread, SIGNAL(started()),  writer, SLOT(process()));
    QObject::connect(writer, SIGNAL(finished()), thread, SLOT(quit()));
    QObject::connect(writer, SIGNAL(finished()), writer, SLOT(deleteLater()));
    QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
    thread->start();

    for (int n = 0; n < 3; ++n) {
        thread = new QThread(qApp);
        Reader* reader = new Reader(n, &data);
        reader->moveToThread(thread);
        QObject::connect(thread, SIGNAL(started()),  reader, SLOT(process()));
        QObject::connect(reader, SIGNAL(finished()), thread, SLOT(quit()));
        QObject::connect(reader, SIGNAL(finished()), reader, SLOT(deleteLater()));
        QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
        thread->start();
    }

    return app.exec();
}
#include "main.moc"

To copy to clipboard, switch view to plain text mode 

[tfgo777]

We are trying to study the available item example in one line into another line, and we have a limitation to sustain fixed varying...What is the new update?

[havij000]

I used the

bool Stuff::thingies[10];

bool Stuff::thingies[10];

To copy to clipboard, switch view to plain text mode 

in the class .cpp file but I face the

error: invalid use of qualified-name 'Data_Class:: prime_rcv_buff_flag'

[ChrisW67]

Paris_Tuileries_Garden_Facepalm_statue.jpg
That was an example not a cut-n-paste prescription. If you actually put that line in your code it would not be addressing your static member problem and certainly not be generating that error message. Error messages without context are absolutely useless to us.

It is all academic anyway because you do not need the static storage class to solve the problem. I have already shown a complete example of data shared between threads that I suggest you read.

---

Added after 5 minutes:

We are trying to study the available item example in one line into another line, and we have a limitation to sustain fixed varying...What is the new update?

Is this a Google Translate (or similar) of a genuine question? It does not seem to have anything to do with this thread.

[VikMorroHun]

I offer a complete example of a multi threaded Qt program sharing data between threads in the hope of dragging this thread into some relevance to Qt:

I had the same problem but your code is a bit complex to me. Here is another solution. Original code and article can be found here.

//widget.h
#ifndef WIDGET_H
#define WIDGET_H
 
#include <QWidget>
#include <QThread>
#include <QMutex>
 
struct Shared {
    volatile int shared_var;
};
 
class Thread : public QThread
{
    Q_OBJECT
 
signals:
    void finishProgress(Shared *);
    void startProgress();
 
public:
    Thread();
    void run();
 
private slots:
    void on_threadReceived(Shared * main_thread_access);
 
private:
    QMutex shared_mutex;
    Shared shared;
    Shared *main_thread_access;
    Shared *worker_thread_access;
};
 
class Widget : public QWidget
{
    Q_OBJECT
 
signals:
    void sender(Shared *);
 
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
 
private slots:
    void on_thread_progressOccured(Shared * worker_thread_access);
 
private:
    Ui::Widget *ui;
    Thread threadA;
    Shared shared;
    Shared *main_thread_access;
    Shared *worker_thread_access;
 
#endif // WIDGET_H
 
//widget.cpp
#include "widget.h"
#include "ui_widget.h" 
 
Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    connect(this, SIGNAL(sender(Shared *)), &threadA, SLOT(on_threadReceived(Shared *)), Qt::QueuedConnection);		//send shared data to different thread
    connect(&threadA, SIGNAL(finishProgress(Shared *)), this, SLOT(on_thread_progressOccured(Shared * )), Qt::QueuedConnection);		//receive shared data from different thread
    main_thread_access = &shared;
    worker_thread_access = NULL;
    main_thread_access->shared_var = 2;
}
 
 
//somewhere in the program
emit sender(main_thread_access);		//we send a signal which carries the shared data to a different thread
 
void Thread::run() {
    worker_thread_access->shared_var += 3;		//modify the shared data
    shared_mutex.unlock();
    emit finishProgress(worker_thread_access);
    quit();
}
 
void Widget::on_thread_progressOccured(Shared * worker_thread_access) {
    main_thread_access->shared_var = worker_thread_access->shared_var;
    if (main_thread_access->shared_var == 2)
        QMessageBox::information(this, tr("Error"), tr("Nothing changed on different thread."));
    else //if (main_thread_access->shared_var == 3)
        QMessageBox::information(this, tr("Ok"), tr("Everything's fine, shared_var == %1.").arg(QString::number(main_thread_access->shared_var)));
	//continuous calling of the other thread keeps incrementing the shared data by three.
}
 
void Thread::on_threadReceived(Shared * main_thread_access) {
    //qDebug() << "thread start";
    shared_mutex.lock();			//Right now I'm not sure about this, maybe a QMutexLocker approach would be better. Or not.
    worker_thread_access->shared_var = main_thread_access->shared_var;
    //qDebug() << main_thread_access->shared_var;
    start();		//we start the other thread here
}

//widget.h
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QThread>
#include <QMutex>

struct Shared {
    volatile int shared_var;
};

class Thread : public QThread
{
    Q_OBJECT

signals:
    void finishProgress(Shared *);
    void startProgress();

public:
    Thread();
    void run();

private slots:
    void on_threadReceived(Shared * main_thread_access);

private:
    QMutex shared_mutex;
    Shared shared;
    Shared *main_thread_access;
    Shared *worker_thread_access;
};

class Widget : public QWidget
{
    Q_OBJECT

signals:
    void sender(Shared *);

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
	
private slots:
    void on_thread_progressOccured(Shared * worker_thread_access);
	
private:
    Ui::Widget *ui;
    Thread threadA;
    Shared shared;
    Shared *main_thread_access;
    Shared *worker_thread_access;
	
#endif // WIDGET_H

//widget.cpp
#include "widget.h"
#include "ui_widget.h" 

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    connect(this, SIGNAL(sender(Shared *)), &threadA, SLOT(on_threadReceived(Shared *)), Qt::QueuedConnection);		//send shared data to different thread
    connect(&threadA, SIGNAL(finishProgress(Shared *)), this, SLOT(on_thread_progressOccured(Shared * )), Qt::QueuedConnection);		//receive shared data from different thread
    main_thread_access = &shared;
    worker_thread_access = NULL;
    main_thread_access->shared_var = 2;
}


//somewhere in the program
emit sender(main_thread_access);		//we send a signal which carries the shared data to a different thread

void Thread::run() {
    worker_thread_access->shared_var += 3;		//modify the shared data
    shared_mutex.unlock();
    emit finishProgress(worker_thread_access);
    quit();
}

void Widget::on_thread_progressOccured(Shared * worker_thread_access) {
    main_thread_access->shared_var = worker_thread_access->shared_var;
    if (main_thread_access->shared_var == 2)
        QMessageBox::information(this, tr("Error"), tr("Nothing changed on different thread."));
    else //if (main_thread_access->shared_var == 3)
        QMessageBox::information(this, tr("Ok"), tr("Everything's fine, shared_var == %1.").arg(QString::number(main_thread_access->shared_var)));
	//continuous calling of the other thread keeps incrementing the shared data by three.
}

void Thread::on_threadReceived(Shared * main_thread_access) {
    //qDebug() << "thread start";
    shared_mutex.lock();			//Right now I'm not sure about this, maybe a QMutexLocker approach would be better. Or not.
    worker_thread_access->shared_var = main_thread_access->shared_var;
    //qDebug() << main_thread_access->shared_var;
    start();		//we start the other thread here
}

To copy to clipboard, switch view to plain text mode 

[havij000]

one more question, how can I start different threads simultaneously in the ui by clicking a sing bottun?

[VikMorroHun]

one more question, how can I start different threads simultaneously in the ui by clicking a sing bottun?

You have to add the necessary yourThread->start() commands or signals to that button's code.

I had the same problem but your code is a bit complex to me. Here is another solution. Original code and article can be found here.

An important thing is missing from the above code, but I can't edit it anymore.

Thread::Thread() {
worker_thread_access = &shared;
}

[anda_skoa]

Oh dear!

Please people, if you are doing multi thread programming, make sure you have read at least about the basics for that topic.

The synchronization mechanism, e.g. the QMutex, obviously needs to be along side the shared data. Using different instances a QMutex for a single instance of shared data does not help you in any way.

It is really very simple:

1) create a data class that protects its data by using QMutex
2) create an instance of that data class
3) pass the data to as many threads as you'd like
4) start the threads

Cheers,
_

[havij000]

another question

how should I set the value of different fields of a data structure that I have defined in the header of my thread class?

#ifndef WRT_RQST_THREAD_H
#define WRT_RQST_THREAD_H
 
#include <QThread>
#include "DDC_Header.h"
 
class Wrt_Rqst_Thread : public QThread
{
    Q_OBJECT
public:
    explicit Wrt_Rqst_Thread(QObject *parent = 0);
 
    void run(QString str, int lngth);
    bool Stop;
 
 
private:
 
    struct wrt_rqst_buff
    {
        unsigned char Dest_MAC[6];
        unsigned char Src_MAC[6];
        unsigned char Eth_Length[2];//should be 0x0800
        unsigned char Wrt_Cmd[2];//should be 0x0000
        unsigned char Base_Addrs[2];
        unsigned char Data_Length[2];//should be 0x02EB
        unsigned char data[1494];//should be set all az 0
 
    }*wrt_buff;
 
signals:
 
public slots:
 
};
 
#endif // WRT_RQST_THREAD_H

#ifndef WRT_RQST_THREAD_H
#define WRT_RQST_THREAD_H

#include <QThread>
#include "DDC_Header.h"

class Wrt_Rqst_Thread : public QThread
{
    Q_OBJECT
public:
    explicit Wrt_Rqst_Thread(QObject *parent = 0);

    void run(QString str, int lngth);
    bool Stop;


private:

    struct wrt_rqst_buff
    {
        unsigned char Dest_MAC[6];
        unsigned char Src_MAC[6];
        unsigned char Eth_Length[2];//should be 0x0800
        unsigned char Wrt_Cmd[2];//should be 0x0000
        unsigned char Base_Addrs[2];
        unsigned char Data_Length[2];//should be 0x02EB
        unsigned char data[1494];//should be set all az 0

    }*wrt_buff;
    
signals:
    
public slots:
    
};

#endif // WRT_RQST_THREAD_H

To copy to clipboard, switch view to plain text mode 

I used

*(unsigned short *) wrt_buff->Data_Length = 0x0080;

*(unsigned short *) wrt_buff->Data_Length = 0x0080;

To copy to clipboard, switch view to plain text mode 

but I faced the memory segmentation error.

[anda_skoa]

Did you create an instance of the data structure?

Cheers,
_

[havij000]

How Can I start different threads simultaneously by clicking on a simple buttom?