最近在学习陈硕大神的muduo库，感觉写的很专业，以及有一些比较“高级”的技巧和设计方式，自己写会比较困难。
于是打算自己写一个简化版本的Reactor模式网络库，就取名叫mini吧，同样只基于Linux平台，不使用boost库，去掉一些比较复杂的部分，只实现比较基本的功能。
写作的过程中，参考了https://github.com/chenshuo/muduo(原始版本的实现)，以及https://github.com/AlexStocks/muduo(去掉boost库的依赖，改用C++11)
就先从用于线程同步的互斥锁和条件变量的封装开始吧，基础部分还会包括一个很简单的日志类、线程封装和简单的线程池。
Linux环境下线程同步的方式有很多，互斥锁、读写锁、自旋锁、条件变量、屏障等都可以作为同步的方式，muduo库使用的是互斥锁+条件变量的方式，原因也很简单，就是简单易用，同时也不失高效性。
为了通用性，使用的都是POSIX的同步原语以及线程实现。
首先是对互斥量的封装：
#ifndef MUTEX_H
#define MUTEX_H
#include <pthread.h>
namespace mini
{
//used as class member
class MutexLock
{
public:
MutexLock()
{
pthread_mutex_init(&mutex_,NULL);
}
~MutexLock()
{
pthread_mutex_destroy(&mutex_);
}
void lock()
{
pthread_mutex_lock(&mutex_);
}
void unlock()
{
pthread_mutex_unlock(&mutex_);
} pthread_mutex_t* getPthreadMutex()
{
return &mutex_;
} private:
pthread_mutex_t mutex_;
};
//used as RAII obj
class MutexLockGuard
{
public:
MutexLockGuard(MutexLock& mutex)
:mutex_(mutex)
{
mutex_.lock();
}
~MutexLockGuard()
{
mutex_.unlock();
} private:
MutexLock& mutex_;
};
} #endif // MUTEX_H
MutexLock是对pthread_mutex的简单封装，包括初始化、加锁、解锁以及销毁，主要用作类的成员变量（比如Condition类、ThreadPool类等）。
MutexLockGuard是一个RAII类，构造时自动加锁，析构时自动解锁，一般用在整个过程都需要加锁的块内（比如一个作用于临界区的函数），可以避免忘记解锁引起的死锁。
然后是对于条件变量的封装：
#ifndef CONDITION_H
#define CONDITION_H
#include "Mutex.h"
#include <pthread.h>
namespace mini
{
class Condition{
public:
Condition(MutexLock& mutex)
:mutex_(mutex)
{
pthread_cond_init(&cond_,NULL);
} ~Condition()
{
pthread_cond_destroy(&cond_);
} void wait()
{
pthread_cond_wait(&cond_,mutex_.getPthreadMutex());
} void notify()
{
pthread_cond_signal(&cond_);
} void notifyAll()
{
pthread_cond_broadcast(&cond_);
} private:
MutexLock& mutex_;//reference, not hold
pthread_cond_t cond_;
};
} #endif // CONDITION_H
Condition类是对pthread_cond的封装，因为条件变量本来就要与mutex配合使用，故而持有一个MutexLock的引用，主要操作是lock()、notify()和notifyAll()。
下面通过一个简单的例子来看看这两个类的使用：
#include <iostream>
#include "Condition.h"
#include <unistd.h> using namespace std;
using namespace mini; mini::MutexLock mutex;
mini::Condition cond(mutex); int count=; void* threadFuncAdd(void*)
{
sleep();
cout<<"ThreadAdd run!"<<endl;
while(count<=)
count++;
cout<<"ThreadAdd finish!"<<endl;
cond.notify();
}
void* threadFuncPrint(void*)
{
mutex.lock();
while(count<=)
{
cout<<"ThreadPrint wait!"<<endl;
cond.wait();
} cout<<"ThreadPrint wake up!"<<endl;
} int main()
{
//count=0;
pthread_t p1,p2;
pthread_create(&p1,NULL,threadFuncAdd,NULL);
pthread_create(&p2,NULL,threadFuncPrint,NULL); sleep(); return ;
}
简单来说，主线程创建了两个线程，一个用来对count进行自加，一个用来等待count值到达100并输出一句话。为了确保print线程会先等待条件，让add线程睡眠了1s。
结果与预期一致，threadprint先进入等待状态，然后threadadd开始执行，并在count自加到1000后，notify() threadprint，threadprint被唤醒。