目录
为了对多线程程序实现同步问题，可以用信号量POSIX信号量、互斥量、条件变量进行线程同步，以达到对共享资源的最大利用。
POSIX信号量
POSIX信号量由sem_ 开头，主要有五个信号量函数。
int sem_init(sem_t* sem,int pshared,unsingned int value);
pshared参数指定信号量的类型，如果为0则代表这个信号量是这个线程局部信号量，否则该信号量就会在多个线程之间共享。
value参数指定信号量的初始值。
不能初始化一个已经被初始化的信号量！！！
int sem_destroy(sem_t* sem);
用于销毁信号量，释放其占用的内核资源
int sem_wait(sem_t* sem);
以原子操作的方式将信号量的值减1，如果信号量为0则被阻塞，知道该信号量具有非0值
int sem_post(sem_t* sem);
//以原子操作方式将信号量加一,信号量大于0时,唤醒调用sem_post的线程
#include<semaphore.h>
//用于初始化一个未命名的信号量
int sem_init(sem_t* sem,int pshared,unsingned int value);
//用于销毁信号量
int sem_destroy(sem_t* sem);
//用以原子操作方式将信号量减一,信号量为0时,sem_wait阻塞
int sem_wait(sem_t* sem);
//相当于sem_wait的非阻塞版本，直接立即返回信号量，无论其是否为0
int sem_trywait(sem_t* sem);
//以原子操作方式将信号量加一,信号量大于0时,唤醒调用sem_post的线程
int sem_post(sem_t* sem);
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;
};互斥量
互斥锁,也成互斥量,可以保护关键代码段,以确保独占式访问.当进入关键代码段,获得互斥锁将其加锁;离开关键代码段,唤醒等待该互斥锁的线程.
#include<pthread.h>
//用于初始化互斥锁
int pthread_mutex_init(pthread_mutex_t* mutex,const pthread_mutexattr* mutexattr);
//用于销毁互斥锁
int pthread_mutex_destroy(pthread_mutex* mutex);
//以原子操作方式给互斥锁加锁
int pthread_mutex_lock(pthread_mutex_t* mutex);
//以原子操作方式给互斥锁解锁
int pthread_mutex_unlock(pthread_mutex_t* mutex);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;
};条件变量
条件变量提供了一种线程间的通知机制,当某个共享数据达到某个值时,唤醒等待这个共享数据的线程.
#include<pthread.h>
//用于初始化条件变量
int pthread_cond_init(pthread_cond_t* cond,const pthread_condatte_t* cond_attr);
//用于销毁条件变量
int pthread_cond_destroy(pthread_cond_t* cond);
//以广播的方式唤醒所有等待目标条件变量的线程
int pthread_cond_broadcast(pthread_cond_t* cond)
/*用于等待目标条件变量.该函数调用时需要传入 mutex参数(加锁的互斥锁) ,函数执行时,先把调用线程放入条件变量的请求队列,然后将互斥锁mutex解锁,当函数成功返回为0时,互斥锁会再次被锁上. 也就是说函数内部会有一次解锁和加锁操作.*/
int pthread_cond_signal(pthread_cond_t* cond);
//用于等待目标条件变量，mutex参数是用于保护条件变量的互斥锁
int pthread_cond_wait(pthread_cond_t* cond,pthread_mutex_t* 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;
};