C++ std::async exécuter sur le thread principal

J'ai lu C++ Simultanéité dans l'Action et le chapitre quatre (AKA "Le Chapitre je Viens de terminer") décrit une solution.

La Version Courte

Ont partagé std::deque<std::packaged_task<void()>> (ou une sorte de message/tâche de la file d'attente). Votre std::async-lancé fonctions peuvent pousser les tâches de la file d'attente, et votre thread GUI peut les traiter au cours de sa boucle.

Il n'est pas Vraiment une Version Longue, mais Voici un Exemple

De Données Partagée

std::deque<std::packaged_task<void()>> tasks;
std::mutex tasks_mutex;
std::atomic<bool> gui_running;

La std::async Fonction

void one_off()
{
    std::packaged_task<void()> task(FUNCTION TO RUN ON GUI THREAD); //!!
    std::future<void> result = task.get_future();

    {
        std::lock_guard<std::mutex> lock(tasks_mutex);
        tasks.push_back(std::move(task));
    }

    //wait on result
    result.get();
}

Le Thread GUI

void gui_thread()
{
    while (gui_running) {
        //process messages
        {
            std::unique_lock<std::mutex> lock(tasks_mutex);
            while (!tasks.empty()) {
                auto task(std::move(tasks.front()));
                tasks.pop_front();

                //unlock during the task
                lock.unlock();
                task();
                lock.lock();
            }
        }

        //"do gui work"
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

Remarques:

1. Je suis (toujours) l'apprentissage, donc il ya une bonne chance que mon code n'est pas grande. Le concept est au moins de son bien.

2. Le destructeur de la valeur de retour de std::async (un std::future<>) bloque jusqu'à ce que l'opération lancée avec std::async complète (voir std::async ), donc en attente sur le résultat d'une tâche (comme je le fais dans mon exemple) dans one_off peut-être pas une idée brillante.

3. Vous souhaitez peut-être (je voudrais, au moins) créez votre propre thread-safe MessageQueue type d'améliorer la lisibilité du code/maintenabilité/bla bla bla.

4. Je vous jure, il y a une chose que je voulais faire remarquer, mais il m'échappe en ce moment.

Exemple Complet

#include <atomic>
#include <chrono>
#include <deque>
#include <iostream>
#include <mutex>
#include <future>
#include <thread>
//shared stuff:
std::deque<std::packaged_task<void()>> tasks;
std::mutex tasks_mutex;
std::atomic<bool> gui_running;
void message()
{
std::cout << std::this_thread::get_id() << std::endl;
}
void one_off()
{
std::packaged_task<void()> task(message);
std::future<void> result = task.get_future();
{
std::lock_guard<std::mutex> lock(tasks_mutex);
tasks.push_back(std::move(task));
}
//wait on result
result.get();
}
void gui_thread()
{
std::cout << "gui thread: "; message();
while (gui_running) {
//process messages
{
std::unique_lock<std::mutex> lock(tasks_mutex);
while (!tasks.empty()) {
auto task(std::move(tasks.front()));
tasks.pop_front();
//unlock during the task
lock.unlock();
task();
lock.lock();
}
}
//"do gui work"
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
}
int main()
{
gui_running = true;
std::cout << "main thread: "; message();
std::thread gt(gui_thread);
for (unsigned i = 0; i < 5; ++i) {
//note:
//these will be launched sequentially because result's
//destructor will block until one_off completes
auto result = std::async(std::launch::async, one_off);
//maybe do something with result if it is not void
}
//the for loop will not complete until all the tasks have been
//processed by gui_thread
//...
//cleanup
gui_running = false;
gt.join();
}

Dat De Sortie

$ ./messages
main thread: 140299226687296
gui thread: 140299210073856
140299210073856
140299210073856
140299210073856
140299210073856
140299210073856

OriginalL'auteur tecu