Annulation d'un fil d'exécution d'une opération longue

... ou ajoutez une méthode d'arrêt () à la classe de thread et faites connaître les objets de travail des threads qu'ils utilisent. Vous pouvez aussi bien lancer une méthode d'arrêt () pour les objets de travail. En fonction de ce qui est plus important: arrêtez le fil ou l'objet de travail.

L'utilisation d'une variable globale n'est en fait pas la pire chose au monde. Avoir une prolifération de variables globales inutiles conduit à des cauchemars de maintenance, mais cela ressemble à une solution rapide et facile à comprendre ici. Mais si vous voulez une solution de OO propre, ceci est certainement possible:

EDIT STROND> Mon message d'origine négligé le fait que vous souhaitez pouvoir exécuter plusieurs opérations en séquence et si l'un d'entre eux est annulé, aucune des opérations restantes n'est effectuée. Cela signifie qu'il est plus utile de conserver le drapeau bool code> à l'intérieur de l'annulation, au lieu de séparément dans chaque opération annulable; Et les exceptions sont le moyen le plus agréable de gérer le flux de contrôle réel. J'ai aussi resserré quelques objets (ajouté volatile code> pour le drapeau lui-même, fait les noms de noms, des droits d'accès inutiles restreints). P>

// A thing that can cancel another thing by setting a bool to true.
class Canceller {
public:
    Canceller : cancelledFlag(false) {}

    void RegisterCancellee(Cancellee const& c) {
        c.RegisterCanceller(cancelledFlag);
    }

    void Cancel() {
        cancelledFlag = true;
    }

private:
    volatile bool cancelledFlag;
};

class CancelButton : public Canceller {
    ...
    // Call Cancel() from on-click event handler
    ...
};

class Cancellation : public std::exception {
public:
    virtual const char* what() const throw() {
        return "User cancelled operation";
    }
};

// A thing that can be cancelled by something else.
class Cancellee {
    friend class Canceller;    // Give them access to RegisterCanceller()

protected:
    Cancellee() : pCancelledFlag(0) {}

    // Does nothing if unconnected
    void CheckForCancellation() {
        if (pCancelledFlag && *pCancelledFlag) throw Cancellation();
    }

private:
    void RegisterCanceller(volatile bool& cancelledFlag) {
        pCancelledFlag = &cancelledFlag;
    }

    volatile bool* pCancelledFlag;
};

class Op1 : public Cancellee {   // (And similarly for Op2 and Op3)
    ...
    // Poll CheckForCancellation() inside main working loop
    ...
};

MyThread
{
    CancelButton cancelButton("CANCEL!");

    try {
        ClassWithLongOperation Op1(10);
        cancelButton.RegisterCancellee(Op1);
        Op1.Run();  // Takes several minutes.

        ClassWithLongOperation Op2(20);
        cancelButton.RegisterCancellee(Op2);
        Op2.Run();

        SomeOtherClassWithLongOperation Op3;
        cancelButton.RegisterCancellee(Op3);
        Op3.Run();
    } catch (Cancellation& c) {
        // Maybe write to a log file
    }

    // Do some other stuff
}