Russian Qt Forum

/*
    private:
       QWaitCondition wait;
       bool flagStop;
       QMutex lock;
*/
public:

void run
{
    for(;!flagStop;)
    {
        lock.lock();
        wait.wait(&lock);

        if (turn.size() == 0)
        {
            lock.unlock();
            continue;
        }
        int tmpSize = turn.size();
        lock.unlock();
        for(;tmpSize != 0;)
        {
            createResultString(getTurn());
            tmpSize--;
         }
    }
}

void addTurn(некие данные inData)
{
    lock.lock();
    turn.push(inData);
    lock.unlock(); 
    wait.wakeAll();
}

    lock.lock();
    // получаем элемент из очереди. разблокируем. обрабатываем.      
    pars tmp;
    tmp = turn.front();
    turn.pop();
    lock.unlock();
    return tmp;

        lock.unlock();
// В этот момент др нитка добавила новую задачу и сделала wakeAll которое  не имеет эффекта
        for(;tmpSize != 0;)
        {

// thread worker
     forever {
     mutex.lock();
     keyPressed.wait(&mutex);
     ++count;
     mutex.unlock();

     do_something();

     mutex.lock();
     --count;
     mutex.unlock();
 }

//control thread
     forever {
     getchar();

     mutex.lock();
     // Sleep until there are no busy worker threads
     while (count > 0) {
         mutex.unlock();
         sleep(1);
         mutex.lock();
     }
     keyPressed.wakeAll();
     mutex.unlock();
 }

 while (count > 0) {
// тут      
         mutex.unlock();
         sleep(1);
         mutex.lock();
// тут
     }

// thread worker
     forever {
     mutex.lock();
     keyPressed.wait(&mutex);     //ждём wake
     ++count;
     mutex.unlock();

     do_something();

     mutex.lock();
     --count;
     mutex.unlock();
 }
                                             
//control thread
     forever {
     getchar();                          // а тут ждём нажатия чела для последующей итерации

     mutex.lock();
     // Sleep until there are no busy worker threads
                                             
     while (count > 0) {              //если есть работающие потоки, тогда даём им захватывать мутекс и закончить обработку.
         mutex.unlock();
         sleep(1);
         mutex.lock();
     }
                                             
     keyPressed.wakeAll();           // пробуждаем потоки все, они просыпаются и ждут освобождения мутекса (или крах если с одного потока)
     mutex.unlock();                   // а тут уже даём им старт
     }

// thread worker
     forever {
     mutex.lock();
     keyPressed.wait(&mutex);     //ждём wake
     ++count;
...

mutex.lock();
     keyPressed.wait(&mutex);
// вот тут поток ждёт.
// Как только происходит wake, mutex захватывается. 
     ++count;
// count инкрементируется
     mutex.unlock();
// анлок для действий

// thread worker
     forever { // мы вот тут стоим
     mutex.lock();
     keyPressed.wait(&mutex);
     ++count;

count  7988   error  0   tmpA  () 

     mutex.lock();
     keyPressed.wait(&mutex);

//Создаём воркеры и управляющий
//count = 0; 
//Проверяем счётчик
mutex.lock();
if (count > 0) // условие не выполнится никогда
    keyPressed.wait(&mutex); 
//Что мы получаем? Ни один поток не начнёт никогда работать. Ибо в начале count = 0. 

// thread worker
forever {
     mutex.lock();
     if (!numTask)
       keyPressed.wait(&mutex);
     if (numTask) {
       --numTask;
       HandleTask();// Вот тут выполняется задача.
     }
     mutex.unlock();
}

//worker 1
lock
функция
unlock
//worker 2
lock
функция
unlock
//worker 3
lock
функция
unlock

lock-unlock // worker'ы прибавили счётчик, освободили мутекс.
//worker 1  worker 2   worker 3
функция    функция   функция
lock-unlock // worker'ы убавили счётчик, освободили мутекс.

Просто добавляем счетчик
// thread worker
forever {
     mutex.lock();
     if (!numTask)
       keyPressed.wait(&mutex);
     if (numTask) {
       --numTask;
       HandleTask();
     }
     mutex.unlock();
}
//control thread
forever {
     getchar();
     mutex.lock();
     CreateTask();
     ++numTask;
     mutex.unlock();
     keyPressed.wakeAll();
}

const int dataSize = 200;
const int bufSize = 10;
std::list<int> listTask;
std::list<QString> rezult;

QMutex mutexRezult;
QMutex mutex;
QWaitCondition bufNotFull;
QWaitCondition bufNotEmpty;

	void run()
	{
		for (int i = 0; i < dataSize; i++)
		{
			mutex.lock();					// Блокирем мютекс
			while (listTask.size() == bufSize)			// Если буфер полный
				bufNotFull.wait(&mutex);			// Ждем побудки буфер не полный

			listTask.push_back(i);				// Генерируем задачу

			bufNotEmpty.wakeAll();				// Побудка что буфер не пустой
			mutex.unlock();					// Разблокируем мютекс
		}
	}

	void run()
	{
		for (int i = 0; i < dataSize; i++)
		{
			mutex.lock();					// Блокируем мютекс
			while (listTask.size() == 0)			// Если буфер пустой
				bufNotEmpty.wait(&mutex);		// Ждем побудки буфер не пустой
			
			int task = *listTask.begin();			// Получаем задачу
			listTask.pop_front();

			bufNotFull.wakeAll();				// Побудка буфер не полный
			mutex.unlock();					// Разблокируем мютекс

			msleep(1 + rand()%100);			// Обрабатываем задачу

			// Выводим результат работы
			QString s = tr("Thread = %1 *** Task = %2").
				arg(m_numThread).
				arg(task);
			mutexRezult.lock();
			rezult.push_back(s);
			mutexRezult.unlock();
		}
	}

	CConsumer consumer1(1);
	CConsumer consumer2(2);
	CConsumer consumer3(3);
	CProducer producer;

	consumer1.start();
  	consumer2.start();
  	consumer3.start();
	producer.start();

bufNotEmpty.wakeAll();		
 <--- сейчас эта нитка владеет мутексом
mutex.unlock();

bufNotEmpty.waitl(&mutex);		
 <--- сейчас эта нитка владеет мутексом
mutex.unlock();