webserver 01 线程同步机制类

目录

1. 信号量class sem

2. 互斥锁class locker

3. 条件变量 class cond

---

1. 信号量class sem

        信号量其实是⼀个整型的计数器，主要⽤于实现进程间的互斥与同步，⽽不是⽤于缓存进程间通信的数据；

        信号量是一种特殊的变量，它只能取自然数值并且只支持两种操作：等待(P)和信号(V).假设有信号量SV，对其的P、V操作如下：

•  P 操作，这个操作会把信号量减去 1，相减后如果信号量 < 0，则表明资源已被占⽤，进程需 阻塞等待；相减后如果信号量 >= 0，则表明还有资源可使⽤，进程可正常继续执⾏。

• 是 V 操作，这个操作会把信号量加上 1，相加后如果信号量 <=0，则表明当前有阻塞中的进程，唤醒； 相加后信号量>0, 表明当前没有阻塞中的进程。

P 操作是⽤在进⼊共享资源之前，V 操作是⽤在离开共享资源之后，这两个操作是必须成对出现的。

信号初始化为0，代表同步信号量以保证进程 A 应在进程 B 之前执⾏

具体过程：

        如果进程B比A先执行，那么执行到P操作的时候，由于信号量初始化为0，执行P操作信号量边为-1，表示进程A还没产生数据，所以B阻塞等待；

        接着进程A生产完数据后执行了V操作，会使信号量边为0，唤醒阻塞在P的B线程

        

信号初始化为1，代表互斥信号量以保证共享内存在任何时刻只有⼀个进程在访 问，这就很好的保护了共享内存。

具体过程：

        进程 A 在访问共享内存前，先执⾏了 P 操作，由于信号量的初始值为 1，故在进程 A 执⾏ P 操作后 信号量变为 0，表示共享资源可⽤，于是进程 A 就可以访问共享内存。

         若此时，进程 B 也想访问共享内存，执⾏了 P 操作，结果信号量变为了 -1，这就意味着临界资源已 被占⽤，因此进程 B 被阻塞。

        直到进程 A 访问完共享内存，才会执⾏ V 操作，使得信号量恢复为 0，接着就会唤醒阻塞中的线程 B，使得进程 B 可以访问共享内存，最后完成共享内存的访问后，执⾏ V 操作，使信号量恢复到初始 值 1。

 sem_t m_sem //定义信号量对象

• sem_init函数用于初始化一个未命名的信号量

• sem_destory函数用于销毁信号量

• sem_wait函数将以原子操作方式将信号量减一,信号量为0时,sem_wait阻塞

• sem_post函数以原子操作方式将信号量加一,信号量大于0时,唤醒调用sem_post的线程

int sem_init(sem_t *sem, int pshared, unsigned int value);

        sem是指向要初始化的信号量的指针，pshared指定了信号量是进程间共享还是线程间共享，value是信号量的初始值。

        pshared被设置为0，那么信号量是线程间共享的，只能被同一进程内的线程访问。如果pshared被设置为非0值，那么信号量是进程间共享的，可以被多个进程访问。

        sem_init函数成功返回0，失败返回-1。在失败的情况下，errno会被设置为相应的错误码。

int sem_post(sem_t* sem);

        它会将指定的信号量的值加1，并唤醒等待在此信号量上的进程。如果没有进程正在等待此信号量，则信号量的值将被加1，但不会唤醒任何进程。

        参数sem是一个指向待释放的信号量的指针。

        该函数返回值为0表示成功，-1表示失败（并设置errno为相应的错误值）。

int sem_wait(sem_t *sem);

        如果信号量的值小于或等于0，则sem_wait函数将阻塞当前线程，直到信号量的值大于0为止。当信号量的值大于0时，sem_wait函数会将信号量的值减1，并返回0，表示信号量可用。    

        其中，sem是指向信号量的指针。

        sem_wait函数的返回值为0表示成功，返回-1表示失败，并设置errno变量来指示错误原因。

class sem
{
public:
    sem()
    {
        if (sem_init(&m_sem, 0, 0) != 0)
        {
            throw std::exception();
        }
    }
    sem(int num)
    {
        if (sem_init(&m_sem, 0, num) != 0)
        {
            throw std::exception();
        }
    }
    ~sem()
    {
        sem_destroy(&m_sem);
    }
    bool wait() 
    {
        return sem_wait(&m_sem) == 0;
    }
    bool post()
    {
        return sem_post(&m_sem) == 0;
    }

private:
    sem_t m_sem;
};

2. 互斥锁class locker

        互斥锁,也成互斥量,可以保护关键代码段,以确保独占式访问.当进入关键代码段,获得互斥锁将其加锁;离开关键代码段,唤醒等待该互斥锁的线程.

• pthread_mutex_init函数用于初始化互斥锁

• pthread_mutex_destory函数用于销毁互斥锁

• pthread_mutex_lock函数以原子操作方式给互斥锁加锁

• pthread_mutex_unlock函数以原子操作方式给互斥锁解锁

      

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

          初始化互斥锁，参数mutex是一个指向pthread_mutex_t类型的指针，用于指向要进行初始化的互斥锁。参数attr是一个指向pthread_mutexattr_t类型的指针，用于指定互斥锁的属性。如果不需要指定属性，则可以将该参数设置为NULL 

class locker
{
public:
    locker()
    {
        if (pthread_mutex_init(&m_mutex, NULL) != 0)
        {
            throw std::exception();
        }
    }
    ~locker()
    {
        pthread_mutex_destroy(&m_mutex);
    }
    bool lock()
    {
        return pthread_mutex_lock(&m_mutex) == 0;
    }
    bool unlock()
    {
        return pthread_mutex_unlock(&m_mutex) == 0;
    }
    pthread_mutex_t *get()
    {
        return &m_mutex;
    }
private:
    pthread_mutex_t m_mutex;
};

3. 条件变量 class cond

        条件变量提供了一种线程间的通知机制,当某个共享数据达到某个值时,唤醒等待这个共享数据的线程. 

• pthread_cond_init函数用于初始化条件变量

• pthread_cond_destory函数销毁条件变量

• pthread_cond_broadcast函数以广播的方式唤醒所有等待目标条件变量的线程

• pthread_cond_wait函数用于等待目标条件变量.该函数调用时需要传入 mutex参数(加锁的互斥锁) ,函数执行时,先把调用线程放入条件变量的请求队列,然后将互斥锁mutex解锁,当函数成功返回为0时,互斥锁会再次被锁上. 也就是说函数内部会有一次解锁和加锁操作.

        销毁条件变量之前，必须确保当前没有线程在等待该条件变量，否则销毁操作将会失败。另外，销毁条件变量的操作不会自动唤醒等待该条件变量的线程，因此必须确保在销毁前，已经唤醒了所有等待该条件变量的线程。 

int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

        线程同步函数，用于等待条件变量的状态改变，调用该函数时，线程会被阻塞，等待条件变量得状态发生改变。如果条件变量得状态没有发生改变，则该函数会一直阻塞线程，直到条件变量状态发生改变或被信号中断。

• cond：指向条件变量的指针
• mutex：指向互斥锁的指针
• 成功时返回0，失败时返回错误码

        pthread_cond_wait函数的使用一般需要与互斥锁一起使用，以确保线程在等待条件变量时不会被其他线程打断。

pthread_cond_wait函数的执行步骤如下：

1. 线程获取互斥锁
2. 线程等待条件变量状态改变
3. 条件变量状态改变后，唤醒等待的线程
4. 线程重新获取互斥锁

int pthread_cond_timedwait(&m_cond, m_mutex, &t)

• cond：指向要等待的条件变量的指针；
• mutex：指向用于保护共享资源的互斥量的指针；
• abstime：指向timespec结构体的指针，用于指定等待时间。

执行过程：

1. 线程调用pthread_cond_timedwait函数并传递条件变量、互斥量和等待时间参数。

2. 线程在等待期间会释放互斥锁并等待条件变量。

3. 如果在指定的等待时间内条件变量被通知，则线程被唤醒，并重新获得互斥锁。

4. 如果在指定的等待时间内条件变量没有被通知，则线程会自动重新获得互斥锁并返回ETIMEDOUT错误代码。

        该函数在等待期间会释放互斥锁，以便其他线程能够修改共享资源。此外，该函数还允许线程在等待期间指定等待时间，以避免无限等待。

pthread_cond_signal(&m_cond)
唤醒等待在条件变量上的一个线程

pthread_cond_broadcast(&m_cond)
唤醒等待在m_cond上的所有线程

class cond
{
public:
    cond()
    {
        if (pthread_cond_init(&m_cond, NULL) != 0)
        {
            //pthread_mutex_destroy(&m_mutex);
            throw std::exception();
        }
    }
    ~cond()
    {
        pthread_cond_destroy(&m_cond);
    }
    bool wait(pthread_mutex_t *m_mutex)
    {
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        ret = pthread_cond_wait(&m_cond, m_mutex);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    //条件变量的等待函数  在指定时间内等待条件变量被唤醒，从而进行相应的处理
    bool timewait(pthread_mutex_t *m_mutex, struct timespec t)
    {
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        /*
        使用pthread_cond_timedwait函数进行等待。该函数会在指定时间内等待条件变量被唤醒，并进行相应的处理。
        如果在等待过程中条件变量被唤醒，则函数返回0；
        如果等待超时，则函数返回一个错误码，表示等待超时。最后，如果等待成功，则返回true，否则返回false
        */
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    //唤醒等待在条件变量m_cond上的某个线程
    //通过判断pthread_cond_signal(&m_cond) == 0来确定是否成功发送信号
    bool signal()
    {
        return pthread_cond_signal(&m_cond) == 0;
    }
    //唤醒所有等待在m_cond上的线程
    //通过判断pthread_cond_broadcast(&m_cond) == 0来确定是否成功发送信号
    bool broadcast()
    {
        return pthread_cond_broadcast(&m_cond) == 0;
    }

private:
    //static pthread_mutex_t m_mutex;
    pthread_cond_t m_cond;
};