Russian Qt Forum

#include <iostream>
#include <QThread>
#include <QList>
#include <QReadWriteLock>

//Дефинируем класс состоящий из FIFO + lock для межпоточного обмена данными
class MyQueue
{
    QReadWriteLock lock;
    QList <int> list;
public:
    int i;
    int getLast() {lock.lockForRead();i = list.last(); lock.unlock(); return i;}
    void addLast(int i) {lock.lockForWrite(); list.push_back(i); lock.unlock();}
};

//Дефинируем класс MyThread полученный из QThread
class MyThread : public QThread {
public:
  MyThread( std::string a = "MyThread" );
  MyQueue myQueue; //внутри нити создаём нашу очередь
private:
  std::string name;
  virtual void run();
};

//Как я понимаю это конструктор
MyThread::MyThread( std::string a ) : name(a)
{}

//Перезагружаем функцию run() тем, что нить должна делать после запуска
void MyThread::run()
{
    int  b = 1;
    myQueue.addLast(b);
    b = myQueue.getLast();
    std::cout << name <<  b  << std::endl;
}


int main()
{
  MyThread a("A");
  MyThread b("B");
  a.start();
  b.start();
  a.wait();
  b.wait();
}

class MyThread : public QThread {

    Q_OBJECT

public:
  MyThread(MyQueue *queue, QObject *parent = 0);
private:
  MyQueue *myQueue; 
protected:
    void run();
};

MyThread::MyThread(MyQueue *queue, QObject *parent)
        : QThread(parent), myQueue(queue)
{
}

void MyThread::run()
{
    int  b = 1;
    myQueue->addLast(b);
    b = myQueue->getLast();
    std::cout <<  b << std::endl;
}

int main()
{
  MyQueue mq;
  MyThread a(&mq);
  MyThread b(&mq);
  a.start();
  b.start();
  a.wait();
  b.wait();
}

#include <iostream>
#include <QThread>
#include <QList>
#include <QMutex>

class MyQueue
{
    QMutex lock;
    QList <int> list;
public:
    int i;
    int getLast() {lock.lock(); i = list.last(); lock.unlock(); return i;}
    void addLast(int i) {lock.lock(); list.push_back(i); lock.unlock();}
};

class WriterThread : public QThread {

public:
  WriterThread(MyQueue *queue, QObject *parent = 0);
private:
  MyQueue *myQueue;
protected:
  void run();
};

WriterThread::WriterThread(MyQueue *queue, QObject *parent)
        : QThread(parent), myQueue(queue)
{
}

void WriterThread::run()
{
    for(int  i = 0; i <= 100; i++)
    {
        myQueue->addLast(i);
        this->msleep(100);
    }
}

class ReaderThread : public QThread {

public:
  ReaderThread(MyQueue *queue, QObject *parent = 0);
private:
  MyQueue *myQueue;
protected:
  void run();
};

ReaderThread::ReaderThread(MyQueue *queue, QObject *parent)
        : QThread(parent), myQueue(queue)
{
}

void ReaderThread::run()
{
    int  i = 0;
    while(i < 100)
    {
        i = myQueue->getLast();
        std::cout <<  i  << std::endl;
    }
}

int main()
{
  MyQueue mq;
  WriterThread a(&mq);
  ReaderThread b(&mq);
  a.start();
  b.start();
  a.wait();
  b.wait();
}

#ifndef MYQUEUE_H
#define MYQUEUE_H

#include <QList>
#include <QMutex>

class MyQueue
{
    QMutex mutex;
    QList <int> list;
public:
    bool getLast( int & i )
    {
       QMutexLocker lock(&mutex);
       if (!list.size()) return false;
       i = list.last();
       return true;
    }

    void addLast( int i )
    {
       QMutexLocker lock(&mutex);
       list.push_back(i);
    }
};

#endif // MYQUEUE_H

#ifndef READERTHREAD_H
#define READERTHREAD_H

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

class ReaderThread : public QThread {

Q_OBJECT

public:
  ReaderThread(MyQueue *queue, QObject *parent = 0);
public slots:
  void NewData( void );
private:
  MyQueue *myQueue;
};

#endif // READERTHREAD_H

#ifndef WRITERTHREAD_H
#define WRITERTHREAD_H

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

class WriterThread : public QThread {

Q_OBJECT

public:
  WriterThread(MyQueue *queue, QObject *parent = 0);
signals:
  void NewData( void );
  void EndJob  ( void );
private:
  MyQueue *myQueue;
protected:
  void run();
};

#endif // WRITERTHREAD_H

#include <iostream>
#include "QApplication.h"
#include "WriterThread.h"
#include "ReaderThread.h"

WriterThread::WriterThread(MyQueue *queue, QObject *parent)
        : QThread(parent), myQueue(queue)
{
}

void WriterThread::run()
{
    for(int  i = 0; i <= 100; i++)
    {
        myQueue->addLast(i);
        emit NewData();
        this->msleep(100);
    }
    emit EndJob();
}

ReaderThread::ReaderThread(MyQueue *queue, QObject *parent)
        : QThread(parent), myQueue(queue)
{
}

void ReaderThread::NewData( void )
{
    int i;
    if (myQueue->getLast(i))
      std::cout <<  i  << std::endl;
}

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  MyQueue mq;
  WriterThread a(&mq);
  ReaderThread b(&mq);
  QObject::connect(&a, SIGNAL(NewData()), &b, SLOT(NewData()), Qt::QueuedConnection);
  QObject::connect(&a, SIGNAL(EndJob()), &b, SLOT(quit()), Qt::QueuedConnection);
  a.start();
  b.start();
  a.wait();
  b.wait();
  return app.exec();
}

#ifndef TASKING_H
#define TASKING_H

#include <QList>
#include <QWaitCondition>
#include <QMutex>
#include <QString>

struct task
{
    int tasknum;
    QString data;
};


class Tasking
{
private:
    QList<task> *taskList;
    QWaitCondition *cond;
    QMutex *mutex;
public:
    Tasking();
    ~Tasking();
    task getTask();
    void addTask(task newTask);
};

#endif // TASKING_H

#include "Tasking.h"

Tasking::Tasking()
{
    mutex = new QMutex;
    taskList = new QList<task>;
    cond = new QWaitCondition;
}

Tasking::~Tasking()
{

}

task Tasking::getTask()
{
    if(!(taskList->count()==0))
    {
        mutex->lock();
        cond->wait(mutex, ULONG_MAX);
        mutex->unlock();
    }

    return taskList->last();
}

void Tasking::addTask(task newTask)
{
    cond->wakeOne();
    taskList->push_back(newTask);
}

#include "thread1.h"


Thread1::Thread1(Tasking *allTasks[], int tasksCount)
{
    Tasks = new Tasking * [tasksCount];
    for(int i = 0; i < tasksCount; i++)
    Tasks[i] = allTasks[i];
}

void Thread1::run()
{
    task myTask;
    myTask.tasknum = 1;
    myTask.data = "something";
    Tasks[0]->addTask(myTask);
    emit showData(myTask.data);
}

#include "thread2.h"

Thread2::Thread2(Tasking *allTasks[], int tasksCount)
{
    Tasks = new Tasking * [tasksCount];
    for(int i = 0; i < tasksCount; i++)
    Tasks[i] = allTasks[i];
}

void Thread2::run()
{
    task myTask;
    myTask = Tasks[0]->getTask();
    emit showData(myTask.data);
}

#include <QtGui/QApplication>

#include "mainwidget.h"
#include "Tasking.h"
#include "thread1.h"
#include "thread2.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWidget w;
    w.show();

    Tasking *allTasks[1];

    Tasking *tasking1 = new Tasking;
    allTasks[0] = tasking1;
    Thread1 myThread1(allTasks, sizeof(allTasks)/sizeof(allTasks[0]));
    Thread2 myThread2(allTasks, sizeof(allTasks)/sizeof(allTasks[0]));

    QObject::connect(&myThread1, SIGNAL(showData(QString)), &w, SLOT(addText(QString)));
    QObject::connect(&myThread2, SIGNAL(showData(QString)), &w, SLOT(addText(QString)));

    myThread1.start();
    myThread2.start();
    myThread1.wait();
    myThread2.wait();

    return a.exec();
}

 if(!(taskList->count()==0))
    {
        mutex->lock();
        cond->wait(mutex, ULONG_MAX);
        mutex->unlock();
    }

void Tasking::addTask(task newTask)
{
    cond->wakeOne();
    taskList->push_back(newTask);
}

    if(taskList.count()==0)
    {
        cond.wait(&mutex, ULONG_MAX);
    }

#include "Tasking.h"

Tasking::Tasking()
{
}

Tasking::~Tasking()
{

}

task Tasking::getTask()
{
    if(taskList.count()==0)
    {
        cond.wait(&mutex, ULONG_MAX);
    }

    mutex.lock();
    task currentTask = taskList.last();
    mutex.unlock();

    return currentTask;
}

void Tasking::addTask(task newTask)
{
    mutex.lock();
    taskList.push_back(newTask);
    mutex.unlock();
    cond.wakeOne();
}

task Tasking::getTask()
{
    mutex.lock();
    if(taskList.count()==0)
        cond.wait(&mutex, ULONG_MAX);

    task currentTask = taskList.last();
    mutex.unlock();

    return currentTask;
}

emit SIGNAL thread id is:  0x15a8 
SLOT SerialThread::TX id is:  0x15a8 
SerialThread::run() id is:  0x157c 

#include "Tasking.h"

Tasking::Tasking()
{
}

Tasking::~Tasking()
{

}

task Tasking::getTask()
{
    while(taskList.empty())
        cond.wait(&mutex, ULONG_MAX);

    mutex.lock();
    task currentTask = taskList.takeFirst();
    mutex.unlock();

    return currentTask;
}

void Tasking::addTask(task newTask)
{
    mutex.lock();
    taskList.append(newTask);
    mutex.unlock();
    cond.wakeOne();
}

Starte D:\C++\Tasking-build-desktop\debug\Tasking.exe...
ASSERT failure in QMutex::unlock(): "A mutex must be unlocked in the same thread that locked it.", file thread\qmutex.cpp, line 371
Invalid parameter passed to C runtime function.
Invalid parameter passed to C runtime function.
D:\C++\Tasking-build-desktop\debug\Tasking.exe beendet, Rückgabewert 3

task Tasking::getTask()
{
    QMutexLocker locker(&mutex);
    while(taskList.empty())
        cond.wait(&mutex, ULONG_MAX);

    return taskList.takeFirst();
}

void Tasking::addTask(task newTask)
{
    QMutexLocker locker(&mutex);
    taskList.append(newTask);
    cond.wakeOne();
}

#include <QList>

#include "mainwidget.h"
#include "Tasking.h"
#include "guithread.h"
#include "thread1.h"
#include "thread2.h"

int main(int argc, char *argv[])
{
    QList<Tasking*> allTasks;

    Tasking *tasking1 = new Tasking;
    Tasking *tasking2 = new Tasking;
    allTasks.append(tasking1);
    allTasks.append(tasking2);

    GUIThread guiThread(allTasks, argc, argv);
    Thread1 myThread1(allTasks);
    Thread2 myThread2(allTasks);

    QObject::connect(&myThread1, SIGNAL(showData(QString)), guiThread.w, SLOT(addText(QString)));
    QObject::connect(&myThread2, SIGNAL(showData(QString)), guiThread.w, SLOT(addText(QString)));

    guiThread.start();
    myThread1.start();
    myThread2.start();
    guiThread.wait();
    myThread1.wait();
    myThread2.wait();

    return 0;
}

#include "guithread.h"

GUIThread::GUIThread(const QList<Tasking*>& allTasks, int argc, char *argv[])
{
    Tasks = allTasks;
    qapp = new QApplication(argc, argv);
    w = new MainWidget(Tasks);
    w->showMW();
}

void GUIThread::run()
{
    qapp->exec();
}

#include "thread1.h"

Thread1::Thread1(const QList<Tasking*>& allTasks)
{
    Tasks = allTasks;
}

void Thread1::run()
{
    task myTask;
    bool exit = FALSE;
    while(!exit)
    {
        myTask = Tasks[0]->getTask();
        switch (myTask.tasknum)
        {
            case 0:
                exit = TRUE;
            case 1:
                emit showData(myTask.data);
                Tasks[1]->addTask(myTask);
        }
    }
}

    myThread1.start();
    myThread2.start();
    qapp.exec();
    myThread1.wait();
    myThread2.wait();