Comment puis-je attendre jusqu'à ce que chaque processus terminé dans keyevents dans Qt?

Question

Je crée un keyevent qui si j'appuie sur la touche "A" fera la fonction A(). Le processus de A() durera 2s. Je veux attendre jusqu'à ce que chaque processus fini si j'appuie sur la touche si rapidement juste comme 4times/2s. J'ai testé et trouvé que si j'appuie sur la touche dans 4times/2s, il fera d'abord le processus dans les événements de pression plus tard. Comment puis-je attendre jusqu'à ce que tous les processus finis dans keyevents? Je dois essayer d'utiliser le fil et le mutex. Mais quelque chose ne va pas. C'est la première fois que j'utilise mutex. Je ne sais pas comment résoudre ce problème.

int g = 0; 
void MainWindow::keyPressEvent(QKeyEvent *event) 
{ 
int keyCode = event->key(); 
if(keyCode == Qt::Key_A) { 
    qDebug() << "da"; 
    a->start(); 
} 
} 


void MyThread::run()// i try to block the second time process while press the key so quickly 
{ 

    mutex->lock(); 
    ...//process:last for 2s 
    g++; 
    mutex->unlock(); 
} 

Answer 1

Si j'ai bien compris, vous utilisez l'action A() à exécuter sur le bouton A enfoncé. Cependant, vous faites l'action A() dans un thread séparé, car vous ne voulez pas bloquer le thread graphique et geler votre interface utilisateur.

Si vous ne voulez pas "sauter" bouton pousse la solution est simple:

1. Créer une QObject factice appelé context.
   QObject* context = new QObject;
2. Appelez QThread appelé thread et opérationnel.
   QThread* thread = new QThread{ this }; thread->start(); ...
3. Avancez ensuite le context au thread avec object->moveToThread(thread).
4. Créez un signal dans votre classe MainWindow, par exemple runA().
5. Connectez ce signal avec avec A() l'action:
   connect(this, &MainWindow::runA, context, []() { A(); });
6. Chaque fois que le bouton "A" est pressé juste émettre ce signal: emit runA();

Chaque fois que le signal est émis, un événement d'action A() à exécuter est affiché dans la boucle d'événement `threads. Tous les événements seront traités dans l'ordre ils sont affichés.

---

#pragma once 

#include <QThread> 
#include <QDebug> 
#include <QWidget> 
#include <QKeyEvent> 

class MainWindow : public QWidget 
{ 
    Q_OBJECT 
private: 
    QThread* thread; 
    QObject* context; 

public: 
    MainWindow() 
     : thread{ new QThread }, 
      context{ new QObject } 
    { 
     context->moveToThread(thread); 
     connect(this, &MainWindow::doAction, context, [this]() { 
      Action(); 
     }); 
     thread->start(); 
    } 
    ~MainWindow() { 
     context->deleteLater(); 
     thread->deleteLater(); 
    } 

signals: 
    void doAction(); 

public: 
    void keyPressEvent(QKeyEvent* event) 
    { 
     int keyCode = event->key(); 
     if(keyCode == Qt::Key_A) { 
      emit doAction(); 
     } 
    } 

    void Action() { 
     qDebug() << "Action is being executed."; 
     QThread::currentThread()->sleep(2); // imitate some long calculation 
    } 
}; 

Peu importe la rapidité avec laquelle vous appuyez sur le bouton "A". "L'action est en cours d'exécution." sera imprimé avec exactement 2 secondes d'intervalle et exactement le nombre de fois que le bouton a été pressé.

Answer 2

Il est pas clair ce qui est nécessaire:

• si vous voulez lancer un fil pour chaque clé d'utilisation pressée QtConcurrent::run(A); sans mutex à l'intérieur A()
• si vous voulez exécuter A() pour chaque touche enfoncée mais pas en même temps utiliser QtConcurrent::run(A); avec un mutex à l'intérieur A() (comme vous l'avez fait)

Answer 3

Une solution rapide consiste à utiliser QtConcurrent::run sur un pool de threads contenant un seul thread. Cela vous absout d'avoir à gérer la durée de vie du fil, une ressource coûteuse - par ex. il sera éliminé après avoir été inutilisé pendant un certain temps pour libérer des ressources.

// https://github.com/KubaO/stackoverflown/tree/master/questions/single-job-lambda-45913311 
#include <QtWidgets> 
#include <QtConcurrent> 

class LogWindow : public QPlainTextEdit { 
    Q_OBJECT 
    QThreadPool m_pool; 
    int g = {}; // can be accessed from the worker thread only 
    void keyReleaseEvent(QKeyEvent * event) override { 
     if (event->key() == Qt::Key_A) 
     QtConcurrent::run(&m_pool, this, &LogWindow::method); 
     QPlainTextEdit::keyReleaseEvent(event); 
    } 
    /// This method must be thread-safe. It is never reentered. 
    void method() { 
     QThread::sleep(2); // block for two seconds 
     g++; 
     emit done(g); 
    } 
    Q_SIGNAL void done(int); 
public: 
    LogWindow(QWidget * parent = {}) : QPlainTextEdit{parent} { 
     appendPlainText("Press and release 'a' a few times.\n"); 
     m_pool.setMaxThreadCount(1); 
     connect(this, &LogWindow::done, this, [this](int val){ 
     appendPlainText(QString::number(val)); 
     }); 
    } 
}; 

int main(int argc, char ** argv) { 
    QApplication app{argc, argv}; 
    LogWindow w; 
    w.show(); 
    return app.exec(); 
} 

#include "main.moc"