关于c++:多线程服务器编程2线程同步精要

线程同步的四项准则

• 最低限度的共享对象，缩小须要同步的场合
• 应用高级的并发构件，如TaskQueue，Producer-Consumer Queue，CountDownLatch等
• 非不得已应用底层同步原语时，只应用非递归的互斥器和条件变量，慎用读写锁，不要应用信号量
• 除了应用atomic整数外，不本人编写lock-free代码，也不要应用内核级同步原语

互斥器（mutex）

应用准则

• 应用RAII手法封装mutex的创立、销毁、加锁、解锁

  • 保障了锁的失效期间等于一个作用域（Scoped Locking）,在死锁产生时有助于定位
  • 保障了不手工调用lock和unlock
  • 保障了不跨过程和线程调用锁
  • 保障了不遗记解锁和反复加锁
• 只应用非递归的mutex（即不可重入的mutex）
• 每次结构Guard对象时，思考一路上曾经持有的锁（函数调用栈），避免因桎梏程序不同导致的死锁

为什么只应用非递归的mutex

• 同一个线程能够反复对递归的mutex加锁，但不能反复对非递归的mutex加锁
• 在同一个县城里屡次对非递归的mutex加锁会导致死锁
• 两者性能差异不大

起因

• 非递归的锁能提前暴露出编程问题

死锁

• 除了线程间的死锁，单个线程也会造成死锁
• 在保障应用Scoped Locking时，能够通过剖析调用栈失去起因

条件变量

应用条件变量实现的BlockingQueue

muduo::MutexLock mutex;
muduo::Condition cond(mutex);
std::deque<int> queue;

int dequeue(){
    MutexLockGuard lock(mutex);
    while(queue.empty()){
        cond.wait(); // unlock mutex and wait (原子地)
    }
    assert(!queue.empty());
    int top = queue.front();
    queue.pop_front();
    return top;
}

void enqueue(int x){
    {
    MutexLockGuard lock(mutex);
    queue.push_back(x);
    }
    cond.notify(); // wakeup the wait side
}

• 每次退出都调用notify()，而不是notifyall()是为了防止惊群效应
• 不只在0->1的时候notify()，而是每加一次告诉一次，是当存在多个消费者时，能高效地唤醒他们，不然只唤醒了一个
• 详见 https://book.douban.com/annot…

应用条件变量实现CountDownLatch(倒计时)

class CountDownLatch : boost::noncopyable{
    public:
        explicit CountDownLatch(int count);
        void wait();
        void countDown();
    private:
        mutable MutexLock mutex_;
        Condition condition_;
        int count_;
}

void CountDownLatch::wait(){
    MutexLockGuard lock(mutex_);
    whilt(count_>0){
        condition_.wait();
    }
}

void CountDownLatch::countDown(){
    MutexLockGuard lock(mutex_);
    --count_;
    if(count_ == 0){
        condition_.notifyAll();
    }
}

封装MutexLock、MutexLockGuard、Condition的实现

class MutexLock : boost::noncopyable{
    public:
        MutexLock()
        :holder_(0)
        {
            pthread_mutex_init(&mutex_NULL);
        }

        ~MutexLock()
        {
            assert(hoilder_ == 0);
            pthread_mutex_destory(&mutex);
        }

        bool isLockedByThisThread(){
            return holder_ == CurrentThread::tid();
        }
        
        void assertLocked(){
            assert(isLockedByThisThread());
        }
        
        void lock(){
            pthread_mutex_lock(&mutex);
            holder_ = CurrentThread::tid();
        }

        void unlock(){
            holder_ = 0;
            pthread_mutex_unlock();
        }

        pthread_mutex_t* getPthreadMutex(){
            return &mutex;
        }
    private:
        pthread_mutex_t mutex_;
        pid_t holder_; 
}

class MutexLockGuard : boost::noncopyable{
    public:
        explicit MutexLockGuard(MutexLock& mutex)
        :mutex_(mutex) 
        {
            mutex_.lock();
        }
        
        ~MutexLockGuard(){
            mutex_.unlock;
        }
    private:
        MutexLock& mutex_;
}

#define MutexLockGuard(x) static_assert(false,"Missing mutex guard variable name!")

class Condition : boost::noncopyable{
    public:
        explicit Condition(MutexLock& mutex)
        :mutex_(mutex)
        {
            pthread_cond_init(&pcond_,NULL);
        }

        ~Condition(){
            pthread_cond_destory(&pcond_);
        }

        void wait(){
            pthread_cond_wait(&pcond_,mutex_.getPthreadMutex());
        }

        void notify(){
            pthread_cond_signal(&pcond_);
        }
        
        void notifyAll(){
            pthread_cond_boardcast(&pcond);
        }

    private:
        MutexLock& mutex_;
        pthread_cond_t pcond_;
}

小结

• 线程同步的四项准则：尽量应用高级同步设施
• 对于其余的工作，应用一般互斥器和条件变量，采纳RAII手法和Scooped Locking