Разработка идёт в версии Qt 5.6.2 + mingw-w64, ОС Windows 10 64-bit.
Вывод данных выполняется с помощью QGraphicsView, QGraphicsScene и QOpenGLWidget.
Запускается процедура отображения данных нажатием кнопки "Multiple files" и управление
передаётся в рабочую нить. В нити формируется QImage из которого получается QPixmap и выводится на экран в цикле.
После каждого следующего нажатия кнопки "Multiple files" Heap увеличивается на 80-100 Мб (видно в VMMap).
После восемнадцати запусков по кнопке "Multiple files" Heap заканчивается и отображение изображений при
последующих нажатиях на кнопку не производится.
Вопрос в том, как реализовать функцию prepare_generate_data(), вызываемую в run() рабочей нити, чтобы
Heap так не рос.

void MainWindow::displayPixmap(const QPixmap &pixmap_data)
{
    QString str;
    graphicspixmapItem=pScene->addPixmap(pixmap_data);
    return;
}
void MainWindow::startWorkInAThread()
{
   /* WorkerThread * */workerThread = new WorkerThread;
    connect(workerThread, &WorkerThread::resultReady,this, &MainWindow::appendtoLogListBox);
    connect(workerThread, &WorkerThread::sendData, this, &MainWindow::displayPixmap);
    connect(workerThread,SIGNAL(finished()), workerThread,SLOT(deleteLater()) );
   // connect(this, &MainWindow::fillDataList, workerThread, &WorkerThread::receiveDataList);
    workerThread->initInnerObjects();
    workerThread->start();
    return;
}
void MainWindow::initializeGL()
{
    QGraphicsView* pView =ui->graphicsView;


    QRect viewRect = pView->rect();
    QRectF viewRectF(viewRect);

    pScene = new QGraphicsScene(viewRectF,this);

    pView->setScene(pScene);

    pOpenGLWidget = new QOpenGLWidget( this );
    QSurfaceFormat format_srf;
    format_srf.setDepthBufferSize(32);
    format_srf.setStencilBufferSize(16);
    format_srf.setVersion(3,2);
    format_srf.setProfile( QSurfaceFormat::CoreProfile );

    pOpenGLWidget->setFormat(format_srf);

    pView->setViewport(pOpenGLWidget);
    return;
}

class WorkerThread : public QThread
{
    Q_OBJECT
public:
    QMutex mutex;
    QWaitCondition wtc_worker2;
    void initInnerObjects(/*const CreatedObject *cObjectsPtr*/)
    {
        wait_cnd=false;
        lock_cnd=false;
        fileSize=0;
    }
    void run() Q_DECL_OVERRIDE {
        QString result;
        forever {
            mutex.lock();
            qDebug() << "--- Worker: run() func, after lock call";
            wait_cnd=wtc_worker2.wait(&mutex,/*5000*/one_and_a_half_hour_wait);
            if(false==wait_cnd)
            {
                mutex.unlock();
                continue;
            }
            else if(true==wait_cnd)
            {
//                prepare_data();
                prepare_generate_data();
                result=QString(tr("--- wait_cnd is true"));
                do_send_result(result);
            }
            qDebug() << "--- wait_cnd is " << wait_cnd;
            qDebug() << "--- Worker: run() func, after wait call";
            mutex.unlock();
        }
    }
    void prepare_generate_data()
    {
        QString str;
       // str.append(" --- slot button6Clicked() ");
       // appendtoLogListBox(str);
        QString filePath;
        QFile file;
        QDataStream dstrm;
        int data_quant=0;
        std::vector<unsigned short> buffer_vect;
        QSize rct_size(320,256);

        QPixmap myPixmap;

        QImage loc_img(rct_size,QImage::Format_RGB32 /*QImage::Format_RGBX8888*/);
       // const uint rgb_value=0xFF000000 /*0*/;
//        QRgb q_rgb;
//        int bytesperLine=0;
//        int bytecount=0;
       // QRgb *pixels;
        QRgb *line;

        pixmap_vect.clear();

        QBuffer hr;

        unsigned long/* long */ start_time=GetTickCount();
        for(int i=0;i<256;i++)
        {
            for(int y=0;y<loc_img.height();y++)
            {
               // QRgb *line=reinterpret_cast<QRgb*>(loc_img.scanLine(y));
                line=static_cast<QRgb *>(static_cast<void *>(loc_img.scanLine(y)));
                for(int x=0;x<loc_img.width();x++)
                {
                    if(x<256-i)
                        line[x]=qRgb(x,x,x);
                    else
                        line[x]=qRgb(0x80,0x80,0x80);
                }
            }
            pixmap_copy=QPixmap::fromImage( loc_img);
            emit sendData(pixmap_copy);
        }

        unsigned long/* long */ end_time=GetTickCount();
        unsigned long/* long */ loc_delta=end_time-start_time;
         str=QString(tr("  --- loc_delta = %1")).arg(loc_delta);
         do_send_result(str);
        loc_list.clear();
        return;
    }
public /*slots*/:
    void launch_threadfunc()
    {
        wtc_worker2.wakeOne();
    }
signals:
    void resultReady(const QString &s);
    void sendData(const QPixmap &pixmap);
public slots:
    void do_send_result(const QString &info_msg)
    {
        emit resultReady(info_msg);
    }
...
};