[数据结构与算法]c语言跨平台条件变量封装

条件变量所为一种线程安全对象，在多线程开发中，是有一些使用场景的，比如多个线程协作执行任务，或者生产者消费者模式的实现，都可以使用条件变量来进行线程控制。c语言做多线程开发，实现一个跨平台条件变量量对象还是有用的。本文提供了一个跨平台条件变量的封装对象，内部实现主要参考sdl的SDL_cond。

一、接口设计：

1、数据结构：

条件变量可以使用2个信号量和一个互斥锁实现，这里为了减少代码冗余以及跨平台宏，直接使用我已经实现的《c语言跨平台信号量封装》和《c语言跨平台互斥锁封装》作为信号量和互斥锁。采用pimp的方式，将实现完全隐藏，头文件不带任何依赖。

#include"acf_mutex.h"
/// <summary>
/// 条件变量对象
/// </summary>
typedef void* acf_cond;

2、方法

（1）、创建条件变量

创建一个条件变量对象。

/// <summary>
/// 创建条件变量
/// </summary>
/// <returns>条件变量对象</returns>
acf_cond acf_cond_create();

（2）、销毁条件变量

条件变量使用完需要销毁。

/// <summary>
/// 销毁条件变量
/// </summary>
/// <param name="cond">条件变量对象</param>
void acf_cond_destroy(acf_cond cond);

（3）、等待信号

条件变量等待信号，需要和一个互斥锁配合使用。

/// <summary>
/// 等待信号
/// </summary>
/// <param name="cond">条件变量对象</param>
/// <param name="mutex">互斥锁</param>
void acf_cond_wait(acf_cond cond, acf_mutex* mutex);

（4）、超时等待信号

可设置等待超时时间，超时后立刻返回。返回0说明等待成功，否则失败。

/// <summary>
/// 超时等待信号
/// </summary>
/// <param name="cond">条件变量对象</param>
/// <param name="mutex">互斥锁</param>
/// <param name="ms">超时时间，单位毫秒</param>
/// <returns>返回0等待成功</returns>
int acf_cond_time_wait(acf_cond cond,  acf_mutex* mutex,int ms);

（5）、发送信号
发送信号，让等待信号的线程继续执行。

/// <summary>
/// 发送信号
/// </summary>
/// <param name="cond"></param>
void acf_cond_signal(acf_cond cond);

?（6）、广播信号
发送信号，让所有等待信号的线程继续执行。

/// <summary>
/// 广播信号
/// </summary>
/// <param name="cond"></param>
void acf_cond_broadcast(acf_cond cond);

三、关键实现

1、等待信号

? ? ? ? 条件变量一般和互斥锁配合使用。首先外部互斥锁加锁后，可能进行一些临界资源的修改，然后进入条件变量等待信号，等待信号之前会先解除外部互斥锁（解除互斥锁的目的是让其他线程条件变量也能进入等待），然后等待信号量，最后接收到信号量，通知发送信号线程接收完成，以及重新加锁还原外部互斥锁状态。

int acf_cond_time_wait(acf_cond cond, acf_mutex* mutex, int ms)
{
	int retval;
	if (!cond) {
		return -1;
	}
	acf_cond_internal* _this = cond;
	//记录等待数量
	acf_mutex_lock(&_this->lock);
	++_this->waiting;
	acf_mutex_unlock(&_this->lock);
	//解除外部的互斥锁，让其他线程可以进入条件等待。
	acf_mutex_unlock(mutex);
	//等待信号
	if (ms == -1) {
		acf_sem_wait(_this->wait_sem);
		retval = 0;
	}
	else {
		retval = acf_sem_time_wait(_this->wait_sem, ms);
	}
	acf_mutex_lock(&_this->lock);
	if (!retval && _this->signals > 0) {
		//通知发送信号的线程，等待完成。
		acf_sem_post(_this->wait_done);
		--_this->signals;
	}
	--_this->waiting;
	acf_mutex_unlock(&_this->lock);
	//加上外部互斥锁，还原外部的锁状态。
	acf_mutex_lock(mutex);
	return retval;
}

2、发送信号

发送等待信号量通知等待的线程，接着进入等待完成信号量进行等待。待等待线程接收到信号后，会发送等待完成的信号，接收到此信号量后即完成了一次信号发送。

void acf_cond_signal(acf_cond cond)
{
	if (!cond) {
		return;
	}
	acf_cond_internal* _this = cond;
	acf_mutex_lock(&_this->lock);
	if (_this->waiting > _this->signals) {
		++_this->signals;
		acf_sem_post(_this->wait_sem);
		acf_mutex_unlock(&_this->lock);
		acf_sem_wait(_this->wait_done);
	}
	else {
		acf_mutex_unlock(&_this->lock);
	}
	return 0;
}

四、使用例子

#include"Thread/acf_thread.h"
#include"Thread/acf_cond.h"
#include<stdio.h>
static acf_cond cond;
static acf_mutex mtx;
static int isReady = 0;
static void producer(void* arg) {
	printf("producer thread  started\n");
	printf("producer thread producting... \n");
	acf_thread_sleep(3000);
	printf("producer thread production comleted and notify conmsumer\n");
	//通知消费者
	acf_mutex_lock(&mtx);
	 isReady = 1;
	acf_mutex_unlock(&mtx);
	acf_cond_signal(cond);
}
static void consumer(void* arg) {
	printf("consume thread  started\n");
	printf("consume thread wait producer notification \n");
	//等待生产者通知
	acf_mutex_lock(&mtx);
	while(!isReady)
	acf_cond_wait(cond, &mtx);
	acf_mutex_unlock(&mtx);
	printf("consume thread got notification \n");
}
int main(int argc, char** argv) {
	//创建条件变量
	cond = acf_cond_create(0);
	acf_mutex_init(&mtx);
	//创建生产者线程
	acf_thread thead1 = acf_thread_create(producer, 0);
	//创建消费者
	acf_thread thead2 = acf_thread_create(consumer, 0);
	acf_thread_wait_destroy(thead1);
	acf_thread_wait_destroy(thead2);
	//销毁条件变量
	acf_cond_destroy(cond);
	acf_mutex_deinit(&mtx);
	return 0;
}

五、完整代码