у меня такое ощущение, что ты совершенно не понимаешь сути параллельной обработки данных.

не поленись, сядь и нарисуй картинку: как всё должно работать, схематически изобрази связи и вызовы и что за чем идёт, стрелками. и потом составь алгоритм обработки, подробно, на бумажке. и только после этого садись писать код. а то ты городишь непонятно что и понятно, что оно не работает. потому что там принципиальные ошибки, даже не программистские, а чисто алгоритмические.

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


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

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

В свое время много-много убил времени на понимание потоков и как 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();
}

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

Большое спасибо. Очень понятный код. Буду разбираться.

У вас опечатка:
QWaitCondition
processingFinished
Еще бы инклуды написали, было бы вообще супер =)

Сообщение отредактировал RazrFalcon - 11.1.2011, 22:59

Извиняюсь за опечатки, я писал за 20 минут до завершения последнего рабочего дня ушедшего года))

Этот код лишь как пример, не стоит слепо следовать ему )

Что мои шаги в многопоточности оооочень медленные.
Может кто нибудь написать мааааленький пример?! В котором будет открываться 10 изображений и поворачиватбся (по 5-ть в потоке), а потом по очереди выводится на форме.

Коментарии к коду выше: Constructor c; - что это?

Мда. Всё гораздо хуже чем я думал
Забудь про многопоточность, забудь про сетевые взаимодействия, забудь вообще про Qt. Для начала подтяни базовые знания с++

ЭЭ... Возможно.
Но мне бы пример...

это уже не "мааааленький пример", а вполне себе функциональная утилитка. ты выбери: либо ты хочет стать программистом и тебе нужно много и долго учиться, либо ты работаешь где угодно, платишь деньги и тебе пишут софт другие люди, которым не лень изучать языки и системы.

Мне 19 лет
И я совершенно точно нигде не работаю.
А теме уже 3-и месяца, и все это время я пытаюсь с потоками разобраться.

Фактически, сейчас у меня проблема только в том что я не понимаю как не дать главному потоку убивать второстепенные до окончания их работы.
Вот если второй поток работает меньше главного (aka main) то все работает отлично.
Вот и все проблема. А пример нежен для наглядности. В мои планы входит изучение языка, в не воровство чужой интеллектуальной собственности.