C++高性能服務器框架 – SYLAR - 線程模塊

線程庫選擇

1. C++11中提供了std::thread, std::mutex, std::condition_variable等線程相關的類。但是還是不夠完善，比如沒有提供讀寫鎖。沒有提供spinlock，雖然c++11裏面的atomic可以用來實現CAS鎖。
2. 對於高併發服務器來說，很多數據，大多數時候，都是寫少讀多的場景。如果沒有讀寫鎖的話，那麼性能上的損失會非常大。
3. 我們開發的這個框架定位是高併發的服務器框架，因此我們還是使用pthread庫來開發（其實c++11裏面的thread也是pthread提供的）

線程類

我們先簡單的用pthread來實現一個簡單的線程類，採用function的方式來，執行用戶需要在線程裏面執行的函數。
function相對於指針函數來說，功能更強大

//線程類的定義
//pthread相關api
//pthread_create, pthread_detach, pthread_join
class Thread {
public:
    typedef std::shared_ptr<Thread> ptr;
    Thread(std::function<void()> cb, const std::string& name);
    ~Thread();

    pid_t getId() const { return m_id;}
    const std::string& getName() const { return m_name;}

    void join();

    static Thread* GetThis();
    static const std::string& GetName();
    static void SetName(const std::string& name);
private:
    Thread(const Thread&) = delete;
    Thread(const Thread&&) = delete;
    Thread& operator=(const Thread&) = delete;

    static void* run(void* arg);
private:
    pid_t m_id = -1;
    pthread_t m_thread = 0;
    std::function<void()> m_cb;
    std::string m_name;

    Semaphore m_semaphore;
};

信號量(Semaphore)

信號量(Semaphore)多用於生產消費者模式，消息隊裏。一個線程負責接收請求，把請求發送到消息隊列，並且把信號+1，其他線程在wait信號，信號大於0時，執行相應行爲，否則就阻塞等待

//相關函數
//sem_init, sem_destroy, sem_wait, sem_post
class Semaphore {
public:
    Semaphore(uint32_t count = 0);
    ~Semaphore();

    void wait();
    void notify();
private:
    Semaphore(const Semaphore&) = delete;
    Semaphore(const Semaphore&&) = delete;
    Semaphore& operator=(const Semaphore&) = delete;
private:
    sem_t m_semaphore;
};

互斥量(Mutex)

用戶多線程操作數據時，做保護，保證同一時間，只有一種操作。保證數據行爲不出錯。
互斥量有多種類型，Mutex，RWMutex，Spinlock 都可以算的上是這一類。保證多線程操作數據的安全

//互斥量
class Mutex {
public:
    typedef ScopedLockImpl<Mutex> Lock;
    Mutex() {
        pthread_mutex_init(&m_mutex, nullptr);
    }

    ~Mutex() {
        pthread_mutex_destroy(&m_mutex);
    }

    void lock() {
        pthread_mutex_lock(&m_mutex);
    }

    void unlock() {
        pthread_mutex_unlock(&m_mutex);
    }
private:
    pthread_mutex_t m_mutex;
};
//讀寫互斥量
class RWMutex {
public:
    typedef ReadScopedLockImpl<RWMutex> ReadLock;
    typedef WriteScopedLockImpl<RWMutex> WriteLock;

    RWMutex() {
        pthread_rwlock_init(&m_lock, nullptr);
    }

    ~RWMutex() {
        pthread_rwlock_destroy(&m_lock);
    }

    void rdlock() {
        pthread_rwlock_rdlock(&m_lock);
    }

    void wrlock() {
        pthread_rwlock_wrlock(&m_lock);
    }

    void unlock() {
        pthread_rwlock_unlock(&m_lock);
    }
private:
    pthread_rwlock_t m_lock;
};
//spinlock
class Spinlock {
public:
    typedef ScopedLockImpl<Spinlock> Lock;
    Spinlock() {
        pthread_spin_init(&m_mutex, 0);
    }

    ~Spinlock() {
        pthread_spin_destroy(&m_mutex);
    }

    void lock() {
        pthread_spin_lock(&m_mutex);
    }

    void unlock() {
        pthread_spin_unlock(&m_mutex);
    }
private:
    pthread_spinlock_t m_mutex;
};

其他

github: https://github.com/sylar-yin/sylar
視頻地址： https://www.bilibili.com/video/av53129011/
個人主頁：http://www.sylar.top/