La classe de threads personnalisés C++ réalise le démarrage et l'arrêt des threads

Vous pouvez l'utiliser pour créer des threads en C++ std::threadou vous pouvez personnaliser une classe de threads pour gérer le cycle de vie des threads. Voici un exemple simple montrant comment personnaliser une classe de thread :

#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>

class MyThread {
public:
    MyThread() {
        m_running = false;
	std::cout << "enter MyThread!\n";
    }

    virtual ~MyThread() {
	std::cout << "enter ~MyThread!\n";
        if (m_running) {
            stop();
        }
    }

    void start() {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (!m_running) {
            m_thread = std::thread(&MyThread::run, this);
            m_running = true;
        }
    }

    void stop() {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_running) {
            m_running = false;
            m_thread.join();
        }
    }

protected:
    virtual void run() {
        while (m_running) {
            // 线程执行的代码
	    std::cout << "Hello from MyThread!\n";
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }

private:
    std::thread m_thread;
    bool m_running;
    std::mutex m_mutex;
};

class MyTask : public MyThread {
protected:
    virtual void run() override {
        // 重写线程执行的代码
	std::cout << "Hello from MyTask!\n";
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
};

int main() {
#if 1
    MyThread thread;
    thread.start();
    // 执行一些操作
    std::this_thread::sleep_for(std::chrono::seconds(3));

    thread.stop();

    ///
    MyTask task;
    task.start();
    // 执行一些操作
    std::this_thread::sleep_for(std::chrono::seconds(3));

    task.stop();

#else

    MyThread thread;
    MyTask task;

    thread.start();
    task.start();
    // 执行一些操作
    std::this_thread::sleep_for(std::chrono::seconds(3));

    thread.stop();
    task.stop();
#endif

    return 0;
}

Dans le code ci-dessus, nous définissons une MyThreadclasse de thread nommée , qui contient des méthodes telles que le démarrage du thread, l'arrêt du thread et l'exécution du thread. Lors du démarrage du thread, nous acquérons un mutex pour assurer la sécurité du thread et ne démarrons le thread que lorsque le thread n'est pas en cours d'exécution. Lors de l'arrêt du thread, un mutex est également acquis pour assurer la sécurité du thread, et l'opération d'arrêt n'est effectuée que lorsque le thread est en cours d'exécution.

De plus, si MyThreadnous utilisons la fonction virtuelle runpour représenter le code exécuté par le thread, cette fonction doit être implémentée dans une sous-classe personnalisée. Par exemple, dans le code ci-dessus, nous définissons une MyTasksous-classe appelée et réécrivons runla fonction pour effectuer la tâche spécifique du thread.

Il convient de noter que lors de la destruction MyThreadde l'objet, nous décidons d'appeler ou non la méthode pour arrêter le thread en jugeant si le thread est en cours d'exécution stop. Cela peut garantir que le thread sera arrêté avant d'être détruit, évitant ainsi des problèmes tels que des plantages de programme.

compiler et exécuter

book@ubuntu:~/Desktop/c++_study$ g++ -o mythread mythread.cpp -lpthread
book@ubuntu:~/Desktop/c++_study$ ./mythread 
enter MyThread!
Hello from MyThread!
Hello from MyThread!
Hello from MyThread!
enter MyThread!
Hello from MyTask!
enter ~MyThread!
enter ~MyThread!