C/C++锁机制（boost）的认知和使用

锁扩充

加锁的必需考虑三个问题

• 该锁的不锁，将会导致各种莫名其妙的错误；
• 加锁范围太大，虽然能避免逻辑错误，但如果锁了不该锁的东西，难免会降低程序的效率；
• 加锁方式不合适，该用临界区的用内核对象等，也会降低程序的效率。

那么何时该加锁？

• 当同时发生多个“写”操作或者同时发生“读写”操作时就应该加锁.

//多线程锁最主要的函数（c语言）
int main()
{
    pthread_mutex_t  write_lock;
    pthread_mutex_init(&write_lock, NULL);
    pthread_mutex_lock(&write_lock);    
    pthread_mutex_unlock(&write_lock);
    pthread_mutex_destroy(&write_lock);
}

线程的创建函数；

int main()
{

    pthread_t tid;
    pthread_create();
    pthread_create(&tid,NULL,CalcAverage,NULL);
    pthread_detach(tid);
}
void *CalcAverage(void *arg)
{
    printf("pthread function");
}
pthrad_deteach

同步

线程同步

指多线程通过特定的东西（如 互斥量）来控制线程之间的执行顺序(同 步）也可以说是在线程之间通过同步建立 起执行顺序的关系，如果没有同步那线程 之间是各自运行各自的

线程同步的四种方式

临界区、互斥区、事件、信号量四种方式 机制

临界区（CriticalSection）、互斥量（M utex）、信号量（Semaphore）、事件（E vent）的区别

• 临界区：通过对多线程的串行化来访 问公共资源或一段代码，速度快，适合控 制数据访问。在任意时刻只允许一个线程 对共享资源进行访问，如果有多个线程试 图访问公共资源，那么在有一个线程进入 后，其他试图访问公共资源的线程将被挂 起，并一直等到进入临界区的线程离开， 临界区在被释放后，其他线程才可以抢占 。

• 互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资 源的权限，因为互斥对象只有一个，所以 能保证公共资源不会同时被多个线程访问 。互斥不仅能实现同一应用程序的公共资 源安全共享，还能实现不同应用程序的公 共资源安全共享

• 信号量：它允许多个线程在同一时刻 访问同一资源，但是需要限制在同一时刻 访问此资源的最大线程数目

• 事 件： 通过通知操作的方式来保持线程的同步， 还可以方便实现对多个线程的优先级比较 的操作

进程间通讯方式

有名管道，无名管道，消息队列，信号，信号量，共享内存，socket

boost 锁：独占式，共享式（mutex 读写锁,lock 互斥锁）

• mutex对象类:

mutex类主要有两种：boost::mutex，boost::shared_mutex，其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，还有shared_lock和shared_unlock方法。因此，boost::mutex为独占互斥类，boost::shared_mutex为共享互斥类。

• 
  
• lock模板类:
  

boost::unique_lock，boost::shared_lock，其中unique_lock为独占锁，shared_lock为共享锁。unique_lock中的T可以为mutex类中的任意一种，如果为shared_mutex，那么boost::unique_lock类的对象构造函数构造时，会自动调用shared_mutex的shared_lock方法，析构函数里，会自动调用shared_mutex的shared_unlock方法。如果是boost:: unique_lock，则分别自动调用lock和unlock方法。
boost::shared_lock中的T只能是shared_mutex类。

---

//读写锁的实现：
typedef boost::shared_lock<boost::shared_mutex> readLock;
typedef boost::unique_lock<boost::shared_mutex> writeLock;
boost::shared_mutex rwmutex;

void readOnly( )
{
       readLock  rdlock( rwmutex );
       //doSvc();
}

void writeOnly( )
{
       writeLock  wtlock( rwmutex );
       /// doSvc();
}

对同一个rwmutex，线程可以同时有多个readLock，这些readLock会阻塞任意一个企图获得writeLock的线程，直到所有的readLock对象都析构。如果writeLock首先获得了rwmutex，那么它会阻塞任意一个企图在rwmutex上获得readLock或者writeLock的线程。boost::shared_lock使用要小心，千万不要同一个线程多次进入。

//互斥锁的实现
typedef boost::unique_lock<boost::mutex> exclusiveLock;

递归式的互斥量

boost::recursive_mutex提供一个递归式的互斥量。对于一个实例最多允许一个线程拥有其锁定，如果一个线程已经锁定一个boost::recursive_mutex实例，那么这个线程可以多次锁定这个实例。

递归式锁

typedef boost::mutex::scoped_lock myScopeLock
boost::mutex io_mutex;
void doJob( )
{
{
myScopeLock mylock( io_mutex); /// 锁定
}
/// 自动解锁
}