TinyWebServer学习笔记-互斥锁、信号量、条件变量

爱躺平的咸鱼

已于 2023-10-03 17:21:15 修改

阅读量279

点赞数

分类专栏： TinyWebServer笔记文章标签：学习笔记

于 2023-10-03 15:55:56 首次发布

本文链接：https://blog.csdn.net/pan_1214_/article/details/133520273

版权

TinyWebServer笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

为什么要使用锁、信号量、条件变量？

网站不可能是单线程的，否则网站的性能和响应都会收到严重的影响。因此，这个项目一定是运行在多线程条件下的。而在多线程条件下，对共享资源的互斥访问就极其重要。

为什么要将资源封装成类？

首先，我们要明确资源的使用一般有三个步骤：

1、获取资源

2、使用资源

3、释放资源

然而，大多数情况下，我们一定能做到前两点，而总是忘记第三步，这就会造成资源的泄露。为了解决这个问题，提出了RAII方案，中文翻译是资源获取即初始化，也就是使用局部对象来管理资源的技术。

最直观的就是将资源封装成类，在构造函数中获取资源，在析构函数中释放资源，这样当变量离开了作用域后，编译器会调用析构函数，而析构函数会帮助我们将资源释放掉，这样就避免了我们忘记释放资源的情况。

本项目中，作者就将锁、互斥量、条件变量进行了封装。有以下好处：

自动资源管理：RAII模式允许资源的获取和释放与对象的生命周期绑定在一起。当对象被创建时，资源被获取；当对象被销毁时，资源被释放。这消除了手动管理资源的需要，减少了错误的机会。

异常安全性：RAII模式提供了异常安全性，因为资源的释放操作通常在对象的析构函数中执行。如果在使用资源的过程中发生异常，对象的析构函数会被自动调用，确保资源被正确释放，防止资源泄漏。

避免忘记释放资源：使用RAII模式，开发人员不需要显式地记住在何处释放资源。资源的释放是自动的，因此避免了因忘记释放资源而引发的问题。

代码可读性：RAII模式使代码更加清晰和容易理解。资源的获取和释放操作都在对象的构造函数和析构函数中，使得代码更加自文档化。

资源的精确生命周期控制：RAII模式允许在对象的生命周期内对资源的生命周期进行精确的控制。资源在对象的构造和析构之间一直存在，不会在对象的其他方法之外被访问。

并发安全性：RAII模式可以用于管理锁、信号量等同步资源，确保线程安全性。资源在锁住和释放锁时被获取和释放，从而避免了竞态条件和死锁等问题。

互斥锁、条件变量、信号量是如何工作的？

互斥锁：提供互斥访问的能力来确保同一时间只有一个线程能够访问共享资源。

1. 锁初始化：创建锁并进行初始化；

2. 加锁：当线程需要访问共享资源时，尝试获取互斥锁，如果已经被别的线程占用，那么该线程会被阻塞，直到锁可用；

3. 访问共享资源：获取锁后，线程访问共享资源；

4. 解锁：该线程访问完共享资源后，释放互斥锁，使其他等待的线程可以获得锁并访问资源。

条件变量：通常和互斥锁一起使用，条件变量用于等待某个条件满足后再继续执行。

1. 等待条件：线程获取互斥锁后，发现条件不足，进入阻塞状态，释放互斥锁，让其他进程可以访问共享资源；

2. 唤醒等待进程：当条件满足后，某个线程通过条件变量发出信号，唤醒一个或多个等待的线程，这些线程被唤醒后后会尝试重新获取互斥锁。

信号量：用于控制多个线程对有限资源的访问。通常有两种：

1.二进制信号量：非0即1，用于互斥访问共享资源。等待信号量为1时获得访问权，将信号量设置为0，访问结束后将信号量值设为1；

2. 计数信号量：可以具有>1的值，控制多个线程对一组有限资源的访问。线程获得资源信号量值变小；释放资源信号量值变大，当信号量值为0时需要阻塞线程。

下面我们来看作者的源代码：

#ifndef LOCKER_H
#define LOCKER_H

#include <exception>
#include <pthread.h>
#include <semaphore.h>

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;
};
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;
};
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);
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    bool signal()
    {
        return pthread_cond_signal(&m_cond) == 0;
    }
    bool broadcast()
    {
        return pthread_cond_broadcast(&m_cond) == 0;
    }

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

互斥锁和信号量是简单的封装，而对于条件变量作者注释掉了互斥锁，但并不会影响互斥访问，因为作者选择用封装好的互斥锁并且在外部来使用。例如在block_queue.h这个文件中，作者将locker m_mutex;作为私有数据成员，并通过get函数获得该锁。

template <class T>
class block_queue
{
public:
    ...
    if (!m_cond.timewait(m_mutex.get(), t))
    {
        m_mutex.unlock();
        return false;
    }
    ...
private:
    locker m_mutex;
    ...
}