Привет всем,
столкнулся с неприятным явлением. Не могу получить больше чем 999 одновремено работающих потоков.
999 - это для потоков, которые не имеют очередь своих сообщений. Для потоков с очередью (тип exec()) - лимит 996.
От количества памяти на компьютере не зависит. Нашел статью, где говорится что в Windows можно открыть 2000 потоков на 1 процесс, почему в Qt в половину меньше, кто-нибудь знает ответ на этот вопрос?

Вот взял код и Qt примеров:

#include <QtCore>

#include <stdio.h>
#include <stdlib.h>

//! [0]
const int DataSize = 10;
const int BufferSize = 8192;

QSemaphore freeBytes(BufferSize);
QSemaphore usedBytes;
//! [0]

//! [1]
class Producer : public QThread
//! [1] //! [2]
{
public:
    void run();
    Producer(){m_exit = false;}
    static int count;
    void stop(){m_exit = true;}
    bool m_exit;
};
 
int Producer::count = 0;

void Producer::run()
{
    
    //fprintf(stderr, "\n %p started", this); 
    //QCoreApplication::processEvents();
    count ++;
    
    char buffer[BufferSize];
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
   // while (!m_exit) {
    //    msleep(1000);
        //fprintf(stderr, "%d", i); 
        //freeBytes.acquire();
        //buffer[i % BufferSize] = "ACGT"[(int)qrand() % 4];
        //usedBytes.release();
   // }
   exec();
    fprintf(stderr, "\n%p finished", this); 
    count --;
}
//! [2]

//! [3]
/*
class Consumer : public QThread
//! [3] //! [4]
{
public:
    void run();
};

void Consumer::run()
{
    for (int i = 0; i < DataSize; ++i) {
        usedBytes.acquire();
        fprintf(stderr, "%c", buffer[i % BufferSize]);
        freeBytes.release();
    }
    fprintf(stderr, "\n");
}
//! [4]
*/
//! [5]
#define THREAD_LIMIT 1100


int main(int argc, char *argv[])
//! [5] //! [6]
{
    QCoreApplication app(argc, argv);
    Producer *producer = new Producer[THREAD_LIMIT];
    //Consumer* consumer = new Consumer[1000];
    for(int i=0;i< THREAD_LIMIT; i++) {
        //producer[i].setStackSize (1* 100 );
        producer[i].start();

       }

    //consumer.start();
    quint64 k=0;
    while((Producer::count < THREAD_LIMIT)&& (k++ < 10000000)) {

        QCoreApplication::processEvents();
       }
        
    fprintf(stderr, "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! %d\n", Producer::count);

    //consumer.wait();
    //for(int i=0;i< THREAD_LIMIT; i++) {
    //    producer[i].stop();
       //}
       
       for(int i=0;i< THREAD_LIMIT; i++) {
       producer[i].quit();
   }
       for(int i=0;i< THREAD_LIMIT; i++) {
        producer[i].wait();
   }
       fprintf(stderr, "\n ----------------------------------------- %d\n", Producer::count);
    delete[]  producer;
    return 0;
}
//! [6]

Не осуждайте за грязь, просто важен сам факт наличия ограничения.