Départ retardé d'un thread en C++ 11

std::threadpar défaut de constructeur instancie un std::thread sans de départ ou une représentation du réel fil.

std::thread t;

De l'opérateur d'affectation se déplace à l'état d'un objet thread, et définit l'attribuées à partir du fil d'objet par défaut-état initialisé:

t = std::thread(/* new thread code goes here */);

Cette première constructions temporaires fil objet représentant un nouveau fil de discussion, les transferts, le nouveau thread représentation de l'objet thread qui a un défaut de l'état, et les ensembles de la temporaire de l'objet thread de l'état à l'état par défaut qui ne représentent pas de thread en cours d'exécution. Puis la temporaire de l'objet thread est détruit, à ne rien faire.

Voici un exemple:

#include <iostream>
#include <thread>

void thread_func(const int i) {
    std::cout << "hello from thread: " << i << std::endl;
}

int main() {
    std::thread t;
    std::cout << "t exists" << std::endl;

    t = std::thread{ thread_func, 7 };
    t.join();

    std::cout << "done!" << std::endl;
}

Il n'y a pas de "standard" de création d'un thread "suspendu" qui je suppose est ce que tu voulais faire avec le C++ bibliothèque de threads. Parce qu'il n'est pas pris en charge sur chaque plate-forme de fils, il n'est pas là dans l'API C++.

1. Vous pouvez créer une classe avec toutes les données, il est nécessaire, mais pas réellement exécuter votre fonction de thread. Ce n'est pas la même chose que de créer le fil, mais peut-être ce que vous voulez. Si oui, créer, puis plus tard lier l'objet et de son operator() ou start() fonction ou quel que soit le fil.

2. Vous pourriez voulez que l'id de thread pour votre thread. Cela signifie que vous n'avez réellement besoin pour démarrer la fonction de thread. Cependant, il peut commencer par en attente sur une variable de condition. Vous avez alors le signal ou une diffusion que la variable de condition plus tard, quand vous le voulez continuer à fonctionner. Bien sûr, vous pouvez avoir la fonction vérifier une condition après il reprend dans le cas où vous pourriez avoir décidé de la fermer et de ne pas courir après tout (auquel cas il va juste retourner instantanément).

3. Vous voudrez peut-être un std::thread objet sans fonction. Vous pouvez le faire et de le joindre à une fonction plus tard à run cette fonction dans un nouveau thread.

Comme antred dit dans réponse, vous pouvez utiliser une variable de condition pour faire le fil de l'attendre dans le début de sa routine.

Scott Meyers dans son livre “Effective C++ Moderne” (le “Point 39: Considérer void avenir pour les one-shot de la communication événementielle”) propose d'utiliser void-avenir, au lieu de la baisse de niveau des entités (indicateur booléen, variable de condition et mutex). Donc, le problème peut être résolu comme ceci:

auto thread_starter = std::promise<void>;
auto thread = std::thread([starter_future = thread_starter.get_future()]() mutable {
    starter_future.wait(); //wait before starting actual work
    …; //do actual work
});
…; //you can do something, thread is like “paused” here
thread_starter.set_value(); //“start” the thread (break its initial waiting)

Scott Meyers met également en garde sur les exceptions dans la deuxième … (marqué par la you can do something, thread is like “paused” here commentaire). Si thread_starter.set_value() n'est jamais appelé pour certaines raisons (par exemple, en raison de l'exception jette dans la deuxième …), le thread va attendre éternellement, et toute tentative de le rejoindre il en résulterait dans l'impasse.

Que les deux méthodes (condvar base et reposant sur l'avenir) contiennent caché l'insécurité, et le premier moyen (condvar) sur les besoins du code réutilisable, je propose d'écrire une classe wrapper autour de std::thread. Son interface devrait être similaire à celui de std::thread (à l'exception de ses instances doit être cessible d'autres instances de la même classe, pas de std::thread), mais contiennent des void start() méthode.

Avenir-fil-wrapper

class initially_suspended_thread {
    std::promise<bool> starter;
    std::thread impl;
public:
    template<class F, class ...Args>
    explicit initially_suspended_thread(F &&f, Args &&...args):
        starter(),
        impl([
            starter_future = starter.get_future(),
            routine = std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        ]() mutable {if (starter_future.get()) routine();})
    {}
    void start() {starter.set_value(true);}
    ~initially_suspended_thread() {
        try {starter.set_value(false);}
        catch (const std::future_error &exc) {
            if (exc.code() != std::future_errc::promise_already_satisfied) throw;
            return; //already “started”, no need to do anything
        }
        impl.join(); //auto-join not-yet-“started” threads
    }
    …; //other methods, trivial
};

Condvar-fil-wrapper

class initially_suspended_thread {
    std::mutex state_mutex;
    enum {INITIAL, STARTED, ABORTED} state;
    std::condition_variable state_condvar;
    std::thread impl;
public:
    template<class F, class ...Args>
    explicit initially_suspended_thread(F &&f, Args &&...args):
        state_mutex(), state(INITIAL), state_condvar(),
        impl([
            &state_mutex = state_mutex, &state = state, &state_condvar = state_condvar,
            routine = std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        ]() {
            {
                std::unique_lock state_mutex_lock(state_mutex);
                state_condvar.wait(
                    state_mutex_lock,
                    [&state]() {return state != INITIAL;}
                );
            }
            if (state == STARTED) routine();
        })
    {}
    void start() {
        {
            std::lock_guard state_mutex_lock(state_mutex);
            state = STARTED;
        }
        state_condvar.notify_one();
    }
    ~initially_suspended_thread() {
        {
            std::lock_guard state_mutex_lock(state_mutex);
            if (state == STARTED) return; //already “started”, no need to do anything
            state = ABORTED;
        }
        impl.join(); //auto-join not-yet-“started” threads
    }
    …; //other methods, trivial
};