Как понять что программа работает в двух потоках? Опции

[RazrFalcon]

Есть простой пример из хелпа

.срр

#include <QtCore/QCoreApplication>
#include <QString>
#include "thread.h"
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyThread th, th2;
    th.start();
    th2.start();
    return a.exec();
}

void MyThread::run()
 {
     for( int count = 0, x=0; count < 20000000; count++, x++ ) 
{
         qDebug()<<x;
     }
 }

.h

#ifndef THREAD_H
#define THREAD_H

#include <qthread.h>
#include <QThread>

class MyThread : public QThread
 {
     Q_OBJECT

 protected:
     void run();
 };



#endif // THREAD_H

.pro

QT       += core thread

QT       -= gui

TARGET = temp
CONFIG   += console
CONFIG   -= app_bundle

TEMPLATE = app


SOURCES += main.cpp

HEADERS += \
    thread.h

а вот вывод такой:
...
406010
406011
406012
406013
406014
406015
...
а по идее должен быть типа
...
406010
406010
406011
406011
406012
406012
...
PS: как присвоить приоритет

th.start(Priority priority = HighestPriority);

Так не хочет (из хелпа)

th2.setPriority(QThread::HighestPriority);

вот так

После применения приоритетов
713245
726544
713246
726545
713247
726546
выходит один спешит? не пойму совсем

"к слову скрин загрузки"

PSS: можно ли выбрать ядро для выполнения функции?

Сообщение отредактировал RazrFalcon - 4.10.2010, 15:01

[RazrFalcon]

Сейчас нарисую
Я и не отрицаю свои ошибки. Я даже точно знаю что они есть.
Проблема что сложно разобраться, вот и мучаюсь. Понемногу.

уже уверен что неправильно

Сообщение отредактировал RazrFalcon - 4.11.2010, 20:03

[PAFOS]

Вклинюсь в дискуссию)

В свое время много-много убил времени на понимание потоков и как Qt с ними обращается))

Для достижения максимальной производительности необходимо создавать столько потоков, сколько физически одновременно может обработать проц.
Для двухядерников идеальным будет два потока, для четырех - четыре.

Еще момент, на создание самого потока у системы уходит уйма времени, поэтому не стоит убивать поток сразу после того как он обработал кадр.
После обработки кадра, поток должен ждать , когда ему сунут новый кадр для обработки.
При таком ожидании лучше всего использовать условные переменные. Условные переменные - разновидность объекта для синхронизации потоков.

Вот код, отображающий все вышеперечисленные моменты)
в коде я предполагаю, что есть класс Frame, который инкапсулирует такую сущность как кадр с камеры.
класс Frame имеет член - int number, который указывает его порядковый номер )

// Класс, который будет обрабатывать кадр в отдельном потоке
class Thread : public QThread
{
    private:
        void run();


    public:
        Frame mFrame;    // Кадр, который будет обрабатывать поток
                // после обрабтки кадра, переменная mFrame должна содержать измененный кадр

        QWainCondition mCondition;
            

    signals:
        // Сигнал испускается потоком, когда тот завершит обработку кадра
        void processingFinished();

    
}


void Thread::run()
{
    QMutex mutex;
    
    for(;;)
    {
        // Здесть мы ожидаем, когда контролирующий поток даст "добро" на обработку кадра
        // предполагается, что перед тем как потоку дадут "добро", переменная mFrame будет содержать кадр, который необходимо обработать
        mutex.lock();
        mCondition.wait(&mutex);
        
        // Код обработки помещаем тут

        // Обработку завершили, высылаем сигнал
        emit processingFiniched();

        mutex.unlock();
    }

    return;
}

// Класс. который распределяет кадры между потоками
class Constructor : public QObject
{
    Q_OBJECT

public:
    // Массив обработанных кадров, в правильном порядке
    QList<Frame> mFrames;


    public slots:
        // Слот, который будет вызываться при завершении одним из потоков обработки кадра
        void on_processingFinished( );
}

// Этот слот будет выполняться в основном потоке программы
void Constructor::on_processingFinished( )
{
    // Так мы определяем какой экземпляр класса завершил обработку
    Thread *t = dynamic_cast<Thread*>( sender() );

    // Получаем обработанный кадр
    Frame frm = t->mFrame;

    // Записываем его в массив, в нужное место
    mFrames[ frm.number() ] = frm;

    // Задаем потоку кадр, который он должен обработать
    t->mFrame = get_next_frame(); 

    // Даем "добро" на обработку кадра
    t->mCondition.wakeOne();
}



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

    Constructor c;

    // Резервируем место в массиве под все кадры
    c.mFrames.reserve( frames_count );

    // Так определяем кол-во потоков, которое РЕАЛЬНО ПАРАЛЛЕЛЬНО могут выполняться в системе
    int ideal_threads = QThread::idealThreadCount();

    // Создаем и запускаем потоки
        for( int i = 0; i < ideal_threads; i++ )
    {
        Thread *t = new Thread;
        // Соединяем сигнал потока о завершении обработки со слотом рапределителя кадром
        connect( t, SIGNAL(processingFinished()), &c, SLOT(on_processingFinished() );
        
        // Запускаем поток
        t->start();

        
        // Задаем кадр, который необходимо обработать потоку
        t->mFrame = get_next_frame();

        // Даем добро на обработку кадра
        t->mCondition.wakeOne();
    }
    

    return a.exec();
}

Вероятно многое может показаться непонятным, но я постараюсь ответить на них )