Compteur Prime

L'exemple suivant montre comment créer une application QtWidgets interactive et non bloquante à l'aide de la classe ` QFutureWatcher ` et des fonctions `filteredReduced ` issues de Qt Concurrent. Grâce à cet exemple, l’utilisateur peut créer une liste de nombres entiers ( QList ) dont la taille peut être modifiée. La liste sera automatiquement remplie de nombres naturels allant de 1 à n. Le programme recherchera ensuite les nombres premiers dans la liste et affichera le nombre total de nombres premiers trouvés.

Exécution de l'exemple

Vous pouvez exécuter l’exemple à partir de :

• Qt Creator

  Ouvrez le mode « Welcome » et sélectionnez l’exemple à l’adresse Examples. Pour plus d’informations, consultez Qt Creator: Tutoriel : Créer et exécuter.

• Qt Extension for Visual Studio Code

  Exécutez la commande « Qt: Open Qt examples » à partir de « Command Palette », puis sélectionnez l’exemple dans la liste. Pour plus d’informations, consultez Qt Extension for Visual Studio Code: Tutoriel : Compiler et exécuter.

Configuration des connexions

La Qt Concurrent bibliothèque fournit les fonctions `filteredReduced `, qui peuvent fonctionner selon deux modes : ` OrderedReduce and UnorderedReduce`. En mode ` OrderedReduce `, la fonction de réduction est appelée dans l’ordre de la séquence d’origine, tandis qu’en mode ` UnorderedReduce `, les éléments sont accédés de manière aléatoire.

Après avoir configuré l’interface utilisateur avec les éléments souhaités, il est nécessaire de les connecter aux signaux des opérations concurrentes à l’aide du mécanisme Qt Signals & Slots. Dans cet exemple, nous utilisons la classe ` QFutureWatcher ` pour surveiller la progression des opérations concurrentes et fournir les signaux nécessaires à la mise en œuvre de l’interface graphique interactive.

    ...
connect(ui->pushButton, &QPushButton::clicked,
        this, [this] { start(); });
connect(&watcher, &QFutureWatcher<Element>::finished,
        this, [this] { finish(); });
connect(&watcher, &QFutureWatcher<Element>::progressRangeChanged,
        ui->progressBar, &QProgressBar::setRange);
connect(&watcher, &QFutureWatcher<Element>::progressValueChanged,
        ui->progressBar, &QProgressBar::setValue);
    ...

La classe ` QFutureWatcher ` joue un rôle essentiel dans cet exemple, car elle fournit les signaux nécessaires à la mise à jour de l’interface utilisateur en réponse aux changements survenant dans les opérations concurrentes.

Lancement de l’opération concurrente

Une fois tous les signaux et slots connectés, lorsque l’utilisateur appuie sur le QPushButton, la fonction ` start() ` est appelée.

Dans la fonction ` start() `, nous appelons la fonction `filteredReduced ` issue de ` Qt Concurrent ` et définissons le `future` sur le membre ` QFutureWatcher `. Pour garantir que cette opération s’exécute véritablement en parallèle, nous spécifions un ` QThreadPool ` distinct comme premier paramètre. Cette approche évite également tout blocage éventuel dans le pool de threads global. Nous transmettons l’ QList, qui contient des entiers, en tant que conteneur, ainsi qu’un filtre statique, une fonction de réduction statique et, enfin, l’indicateur « ReduceOption ».

    ...
void PrimeCounter::start()
{
    if (ui->pushButton->isChecked()) {
        ui->comboBox->setEnabled(false);
        ui->pushButton->setText(tr("Cancel"));
        ui->labelResult->setText(tr("Calculating ..."));
        ui->labelFilter->setText(tr("Selected Reduce Option: %1").arg(ui->comboBox->currentText()));
        fillElementList(ui->horizontalSlider->value() * stepSize);

        timer.start();
        watcher.setFuture(
            QtConcurrent::filteredReduced(
                &pool,
                elementList,
                filterFunction,
                reduceFunction,
                currentReduceOpt | QtConcurrent::SequentialReduce));
    ...

Examinons les fonctions `filter` et `reduce`. Dans cet exemple, ces fonctions sont déclarées statiques car elles ne dépendent d’aucune variable membre. Elles pourraient toutefois facilement être définies sous forme de lambda ou de fonctions membres.

La fonction `filter` marque les éléments en vue d’une réduction ultérieure par la fonction `reduce`. Cette implémentation est un simple filtre de nombres premiers. Comme cette fonction prend une référence `const` en argument, elle permet une opération sans risque de concurrence sur le conteneur sur lequel elle opère.

    ...
bool PrimeCounter::filterFunction(const Element &element)
{
    // Filter for primes
    if (element <= 1)
        return false;
    for (Element i = 2; i*i <= element; ++i) {
        if (element % i == 0)
            return false;
    }
    return true;
}
    ...

La fonction `reduce` prend comme premier paramètre une référence modifiable du même type que le conteneur sur lequel elle opère. Le deuxième paramètre est l’élément précédemment filtré par la fonction `filter`. Dans cet exemple, nous comptons le nombre de nombres premiers.

    ...
void PrimeCounter::reduceFunction(Element &out, const Element &value)
{
    // Count the amount of primes.
    Q_UNUSED(value);
    ++out;
}
    ...

Exemple de projet @ code.qt.io