我有以下经理<->员工情况:

class Manager {
private:
    pthread_attr_t workerSettings;
    pthread_t worker;
    pthread_cond_t condition;
    pthread_mutex_t mutex;
    bool workerRunning;

    static void* worker_function(void* args) {
        Manager* manager = (Manager*)args;

        while(true) {
            while(true) {
                pthread_mutex_lock(&manager->mutex);
                if(/* new data available */)
                {
                    /* copy new data from shared to thread memory */
                    pthread_mutex_unlock(&manager->mutex);
                }
                else
                {
                    pthread_mutex_unlock(&manager->mutex);
                    break;
                }

                /* process the data in thread memory */

                pthread_mutex_lock(&manager->mutex);
                /* copy results back to shared memory */
                pthread_mutex_unlock(&manager->mutex);
            }

            pthread_mutex_lock(&manager->mutex);

            // wait for new data to arrive
            while(manager->workerRunning && !/* new data available*/)
                pthread_cond_wait(&manager->condition, &manager->mutex);

            // check if we should continue running
            if(!manager->workerRunning)
            {
                pthread_mutex_unlock(&manager->mutex);
                break;
            }

            pthread_mutex_unlock(&manager->mutex);
        }

        pthread_exit(NULL);
        return NULL; // just to avoid the missing return statement compiler warning
    }

public:
    Manager() : workerRunning(true) {
        pthread_cond_init(&condition, NULL);
        pthread_mutex_init(&mutex, NULL);
        pthread_attr_init(&workerSettings);
        pthread_attr_setdetachstate(&workerSettings, PTHREAD_CREATE_JOINABLE);
        pthread_create(&worker, &workerSettings, worker_function, (void*)this);
    }

    // this *may* be called repeatedly or very seldom
    void addData(void) {
        pthread_mutex_lock(&mutex);
        /* copy new data into shared memory */
        pthread_cond_signal(&condition);
        pthread_mutex_unlock(&mutex);
    }

    ~Manager()
    {
        // set workerRunning to false and signal the worker
        pthread_mutex_lock(&mutex);
        workerRunning = false;
        pthread_cond_signal(&condition);
        pthread_mutex_unlock(&mutex);

        // wait for the worker to exit
        pthread_join(worker, NULL);

        // cleanup
        pthread_attr_destroy(&workerSettings);
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&condition);
    }
};

我在几个地方对此并不完全确定:

• Manager 在其构造函数中生成一个新线程这一事实是否被认为是一种不好的做法？ (我将只有一个 Manager 对象，所以我想应该没问题)
• pthread_exit 怎么样 - 我在很多教程中都看到过这个，但我不太明白为什么它应该在那里？我不能简单地返回退出线程的函数吗？我还认为返回 NULL 是死代码，但是 gcc 会在它丢失时发出警告，因为它显然不知道 pthread_exit 已经在此时终止了线程。
• 关于构造函数 - 我可以在生成线程后立即销毁线程属性对象 (workerSettings) 还是必须在线程的整个生命周期内保持有效？
• 关于析构函数:这是执行此操作的正确方法吗？

最重要的是:

• 您有经验的眼睛是否看到那里有任何同步问题？

感谢您的帮助!

最佳答案

你问...

Is the fact that Manager spawns a new thread in its constructor considered a bad practice?

在大多数情况下，RAII 足以处理对象创建和资源获取。在某些情况下，您可能希望实现延迟资源初始化:当您首先构造一个对象，然后再进行初始化时。例如，这可以通过构造函数(默认或参数化)和打开/启动例程来实现。尽管您也可以在 ctor 中执行此操作并通过在进程堆中分配对象(通过 operator new)来实现延迟对象创建。这取决于您的要求、软件设计考虑因素和企业软件开发标准。 因此，您可以在 ctor 中创建一个线程，或者可能希望或需要在应用程序/对象生命周期的后期生成它。

What about the pthread_exit

这不是必需的。它终止调用线程，使其退出状态可用于任何等待线程(即通过 pthread_join())。当任何线程从其启动例程返回时，将发生对 pthread_exit() 的隐式调用。基本上，pthread_exit() 函数提供了一个类似于 exit() 的接口(interface)，但基于每个线程(包括取消清理处理程序)。但要注意从取消清理处理程序或从 TSD(线程特定数据区域)中分配的对象的析构函数调用 pthread_exit() - 它可能导致不良副作用。

About the constructor - can i destroy the thread attr object (workerSettings) immediately after spawning the thread or does it have to stay valid for the entire lifetime of the thread?

是的，您可以立即销毁它:它不会影响已经创建的线程。

About the destructor: Is this the right way to do this?

与 ctor 相同:您可以使用 dtor 和关闭/停止例程，或者可以在 dtor 中完成所有操作:取决于您的特定需求(例如对象可重用性等)。只是让 dtor 不抛出。

Do your experienced eyes see any synchronization issues there?

我可能建议使用 pthread_testcancel()，在线程中引入显式取消点，并在控制线程中发出 pthread_cancel() + pthread_join()(应该返回 PTHREAD_CANCELED)来停止子线程，而不是同步变量 workerRunning .当然，如果它适用于您的情况。

关于c++ - PThread 初学者 - 启动、同步、停止工作线程，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11203194/