【Linux】线程封装与互斥

在Linux下，我们可以使用pthread库中的函数来进行线程的封装和互斥操作。以下是一个简单的线程封装类的示例代码：

#include <pthread.h>
#include <iostream>
#include <unistd.h>
 
class Thread {
public:
    Thread() {
        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
    }
 
    virtual ~Thread() {
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }
 
    void start() {
        pthread_create(&thread_id, NULL, thread_func, this);
    }
 
    void join() {
        pthread_join(thread_id, NULL);
    }
 
    void signal() {
        pthread_mutex_lock(&mutex);
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
    }
 
    void wait() {
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond, &mutex);
        pthread_mutex_unlock(&mutex);
    }
 
protected:
    virtual void run() = 0;
 
private:
    pthread_t thread_id;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
 
    static void* thread_func(void* arg) {
        static_cast<Thread*>(arg)->run();
        return nullptr;
    }
};
 
class MyThread : public Thread {
protected:
    void run() override {
        std::cout << "Thread is running..." << std::endl;
        sleep(1); // 模拟耗时操作
    }
};
 
int main() {
    MyThread my_thread;
    my_thread.start();
    my_thread.join();
    return 0;
}

这个示例中，我们定义了一个Thread类，它封装了线程的创建、等待和通知机制。MyThread类继承自Thread类，并实现了run方法，这个方法将在新线程中被调用。在main函数中，我们创建了一个MyThread对象，启动了线程，并等待其结束。这个示例展示了如何使用类封装线程操作，并提供了一个简单的互斥机制，用于线程间的同步。