首先是头文件handler.h

#include <stdio.h>
#include <pthread.h>

struct list_head {
	struct list_head *prev, *next;
};

#define list_entry(ptr, type, member) \
	((type *)((uintptr_t)(ptr) - (uintptr_t)offsetof(type, member)))

#define list_first_entry(ptr, type, member) \
	list_entry((ptr)->next, type, member)

#define list_for_each_entry(pos, head, member, type)			\
	for (pos = list_entry((head)->next, type, member);		\
		 &pos->member != (head);				\
		 pos = list_entry(pos->member.next, type, member))

#define list_for_each_entry_safe(pos, n, head, member, type)		\
	for (pos = list_entry((head)->next, type, member),		\
		 n = list_entry(pos->member.next, type, member);	\
		 &pos->member != (head);				\
		 pos = n, n = list_entry(n->member.next, type, member))

#define list_empty(entry) ((entry)->next == (entry))

static inline void list_init(struct list_head *entry)
{
	entry->prev = entry->next = entry;
}

static inline void list_add(struct list_head *entry, struct list_head *head)
{
	entry->next = head->next;
	entry->prev = head;

	head->next->prev = entry;
	head->next = entry;
}

static inline void list_add_tail(struct list_head *entry,
	struct list_head *head)
{
	entry->next = head;
	entry->prev = head->prev;

	head->prev->next = entry;
	head->prev = entry;
}

static inline void list_del(struct list_head *entry)
{
	entry->next->prev = entry->prev;
	entry->prev->next = entry->next;
	entry->next = entry->prev = NULL;
}

static inline void list_cut(struct list_head *list, struct list_head *head)
{
	if (list_empty(head))
		return;

	list->next = head->next;
	list->next->prev = list;
	list->prev = head->prev;
	list->prev->next = list;

	list_init(head);
}

static inline void *usbi_reallocf(void *ptr, size_t size)
{
	void *ret = realloc(ptr, size);
	if (!ret)
		free(ptr);
	return ret;
}

#define container_of(ptr, type, member) ({			\
	const typeof( ((type *)0)->member ) *mptr = (ptr);	\
	(type *)( (char *)mptr - offsetof(type,member) );})

enum handle_code {
	SUCCESS,
	NO_MEMORY = -1,
	INIT_FAILED = -2,
};

struct message {
	int what;
	int arg1;
	int arg2;
	void *user_data;
	struct list_head list;

};

然后是handler.c, obtain_message可以取缓存的message，测试代码也放在handler.c中，测试不完全，如有bug，欢迎指正，谢谢。

#include "handler.h"

struct message_control {

	pthread_mutex_t lock;
	pthread_cond_t cond;
	struct list_head list;
	int cache_list_number;
	struct list_head cache_list;

};

static struct message_control *s_msg_ctl;


void wait_for_message(struct message **msg)
{
	pthread_mutex_lock(&s_msg_ctl->lock);

	struct message *tmp_msg;

	if(list_empty(&s_msg_ctl->list)) {
		pthread_mutex_unlock(&s_msg_ctl->lock);
		pthread_cond_wait(&s_msg_ctl->cond, NULL);
		pthread_mutex_lock(&s_msg_ctl->lock);
	}

	tmp_msg = *msg = list_first_entry(&s_msg_ctl->list, struct message, list);
	list_del(&tmp_msg->list);

	list_add_tail(&tmp_msg->list, &s_msg_ctl->cache_list);
	s_msg_ctl->cache_list_number++;

	pthread_mutex_unlock(&s_msg_ctl->lock);
}

void free_message(struct message *msg) {

	pthread_mutex_lock(&s_msg_ctl->lock);

	struct message *tmp_msg;

	list_for_each_entry(tmp_msg, &s_msg_ctl->cache_list, list, struct message) {
		if(msg == tmp_msg) {
			break;
		}
	}
	if(tmp_msg)
	{
		list_del(&tmp_msg->list);
		s_msg_ctl->cache_list_number--;
		free(tmp_msg);
		tmp_msg = NULL;
	}

	pthread_mutex_unlock(&s_msg_ctl->lock);
}

struct message *obtain_message() {

	pthread_mutex_lock(&s_msg_ctl->lock);
	struct message *msg = NULL;
	if(list_empty(&s_msg_ctl->cache_list)) {
		msg = calloc(1, sizeof(struct message));
	} else {
		msg = list_first_entry(&s_msg_ctl->cache_list, struct message, list);
	}
	pthread_mutex_unlock(&s_msg_ctl->lock);

	return msg;
}

void send_message(struct message *msg)
{
	pthread_mutex_lock(&s_msg_ctl->lock);

	list_add_tail(&msg->list, &s_msg_ctl->list);

	pthread_cond_broadcast(&s_msg_ctl->cond);

	pthread_mutex_unlock(&s_msg_ctl->lock);
}

int init_handler()
{
	s_msg_ctl = calloc(1, sizeof(struct message_control));
	if(!s_msg_ctl)
	{
		return NO_MEMORY;
	}
	list_init(&s_msg_ctl->list);
	list_init(&s_msg_ctl->cache_list);
	pthread_mutex_init(&s_msg_ctl->lock, NULL);
	pthread_cond_init(&s_msg_ctl->cond, NULL);
	s_msg_ctl->cache_list_number = 0;

	return 0;
}

//=======================================================================================================================



void *thread_handler(void *param)
{
	struct message *msg;
	while(1) {

		wait_for_message(&msg);

		printf("receive a message what:%d, arg1:%d, arg2:%d, %s\n", msg->what, msg->arg1, msg->arg2, (char *)msg->user_data);

	}

	return NULL;
}


int main()
{
	init_handler();
	sleep(1);

	pthread_t handler_tid;
	pthread_create(&handler_tid, NULL, thread_handler, NULL);


	while(1) {
		printf("sleep 1\n");
		sleep(1);
		printf("sleep 2\n");
		struct message *msg = obtain_message();
		printf("obtain_message:%p\n", msg);
		msg->what = 1;
		msg->arg1 = 1;
		msg->arg2 = 1;
		msg->user_data = "hello handler message";
		send_message(msg);

	}
	while(1){
		sleep(22);
	}
	return 0;
}