超轻量 pthread 集结点实现

我需要的 pthread 线程集结点功能，使用同一集结点的线程将通过 rend_wait 函数等待，当集结点到达指定数量的线程后同时激发继续执行。使用 pthread 的 mutex 和 cond 超轻量实现。下面 rend.h 是集结点实现，rendezvous.c 是测试应用。

C代码

1. /*
2. *rend.h
3. *
4. *Createdon:2009-11-14
5. *Author:liuzy(lzy.dev@gmail.com)
6. */
8. #ifndefREND_H_
9. #defineREND_H_
11. #include<pthread.h>
12. #include<assert.h>
14. structrend_t{
15. volatileintcount;
16. pthread_mutex_tcount_lock;
17. pthread_cond_tready;
18. };
20. #defineDECLARE_REND(name,count)/
21. structrend_tname={(count),PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER}
23. intrend_init(structrend_t*prend,intcount){
24. intret=0;
26. assert(prend);
28. prend->count=count;
30. if((ret=pthread_mutex_init(&prend->count_lock,NULL)))
31. returnret;
33. if((ret=pthread_cond_init(&prend->ready,NULL)))
34. returnret;
36. returnEXIT_SUCCESS;
37. }
39. intrend_wait(structrend_t*prend){
40. intret=0;
42. assert(prend);
44. if((ret=pthread_mutex_lock(&prend->count_lock)))
45. returnret;
47. /*checkcountvalueisreadytoweakupblockcode*/
48. if(prend->count==1){
49. if((ret=pthread_cond_broadcast(&prend->ready)))
50. returnret;
52. if((ret=pthread_mutex_unlock(&prend->count_lock)))
53. returnret;
54. }else{
55. prend->count--;
57. ret=pthread_cond_wait(&prend->ready,&prend->count_lock);
58. prend->count++;
60. if(ret){
61. pthread_mutex_unlock(&prend->count_lock);
62. returnret;
63. }
65. if((ret=pthread_mutex_unlock(&prend->count_lock)))
66. returnret;
67. }
69. returnEXIT_SUCCESS;
70. }
72. intrend_free(structrend_t*prend){
73. intret=0;
75. assert(prend);
77. prend->count=0;
79. if((ret=pthread_mutex_destroy(&prend->count_lock)))
80. returnret;
82. if((ret=pthread_cond_destroy(&prend->ready)))
83. returnret;
85. returnEXIT_SUCCESS;
86. }
88. #endif/*REND_H_*/

/*
 * rend.h
 *
 *  Created on: 2009-11-14
 *      Author: liuzy (lzy.dev@gmail.com)
 */

#ifndef REND_H_
#define REND_H_

#include <pthread.h>
#include <assert.h>

struct rend_t {
	volatile int count;
	pthread_mutex_t count_lock;
	pthread_cond_t ready;
};

#define DECLARE_REND(name, count) /
	struct rend_t name = {(count), PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER}

int rend_init(struct rend_t* prend, int count) {
	int ret = 0;

	assert(prend);

	prend->count = count;

	if ((ret = pthread_mutex_init(&prend->count_lock, NULL)))
		return ret;

	if ((ret = pthread_cond_init(&prend->ready, NULL)))
		return ret;

	return EXIT_SUCCESS;
}

int rend_wait(struct rend_t* prend) {
	int ret = 0;

	assert(prend);

	if ((ret = pthread_mutex_lock(&prend->count_lock)))
		return ret;

	/* check count value is ready to weak up block code */
	if (prend->count == 1) {
		if ((ret = pthread_cond_broadcast(&prend->ready)))
			return ret;

		if ((ret = pthread_mutex_unlock(&prend->count_lock)))
			return ret;
	} else {
		prend->count--;

		ret = pthread_cond_wait(&prend->ready, &prend->count_lock);
		prend->count++;

		if (ret) {
			pthread_mutex_unlock(&prend->count_lock);
			return ret;
		}

		if ((ret = pthread_mutex_unlock(&prend->count_lock)))
			return ret;
	}

	return EXIT_SUCCESS;
}

int rend_free(struct rend_t* prend) {
	int ret = 0;

	assert(prend);

	prend->count = 0;

	if ((ret = pthread_mutex_destroy(&prend->count_lock)))
		return ret;

	if ((ret = pthread_cond_destroy(&prend->ready)))
		return ret;

	return EXIT_SUCCESS;
}

#endif /* REND_H_ */

rend 使用更简单：

1. 定义/初始化 rend_t 集结点对象。DECLARE_REND 宏用于静态定义，rend_init 函数可以对动态创建的集结点结构初始化；
2. pthread 线程通过调用 rend_wait 函数 P/V 集结状态。集结关系的线程要 P/V 在同一个 rend_t 集结对象上；
3. 释放集结对象，rend_free 函数。

以上函数都是成功返回 0，出错返回 errno 值（非 0）。

C代码

1. /*
2. ==============================
3. Name:rendezvous.c
4. Author:liuzy(lzy.dev@gmail.com)
5. Version:0.1
6. ==============================
7. */
9. #include<stdio.h>
10. #include<stdlib.h>
11. #include<stdarg.h>/*va_list*/
12. #include<unistd.h>
13. #include<string.h>
14. #include<errno.h>/*errno*/
15. #include<syslog.h>/*forsyslog(2)andlevel*/
16. #include<pthread.h>
18. #include"rend.h"
20. staticintdaemon_proc=0;/*forsysloginerr_doit*/
22. #defineMAXLINE4096/*maxtextlinelength*/
24. voiderr_doit(interrnoflag,intlevel,constchar*fmt,va_listap){
26. charbuf[MAXLINE+1]={0};
27. interrno_save=errno,n=0;
29. #ifdefHAVE_VSNPRINTF
30. vsnprintf(buf,MAXLINE,fmt,ap);
31. #else
32. vsprintf(buf,fmt,ap);
33. #endif/*HAVE_VSNPRINTF*/
35. n=strlen(buf);
36. if(errnoflag)
37. snprintf(buf+n,MAXLINE-n,":%s",strerror(errno_save));
38. strcat(buf,"/n");
40. if(daemon_proc){
41. syslog(level,"%s",buf);
42. }else{
43. fflush(stdout);
44. fputs(buf,stderr);
45. fflush(stderr);
46. }
48. return;
49. }
51. voiderr_msg(constchar*fmt,...){
52. va_listap;
54. va_start(ap,fmt);
55. err_doit(0,LOG_INFO,fmt,ap);
56. va_end(ap);
58. return;
59. }
61. voiderr_sys(constchar*fmt,...){
62. va_listap;
64. va_start(ap,fmt);
65. err_doit(1,LOG_ERR,fmt,ap);
66. va_end(ap);
68. exit(EXIT_FAILURE);
69. }
71. #defineTHREAD_COUNT100/*rendezvoustestthreadworkers*/
73. structworker_arg{
74. intworker_id;
75. structrend_t*prend;
76. };
78. staticvoid*pthread_worker(void*arg){
79. structworker_arg*parg=(structworker_arg*)arg;
81. err_msg("worker#%drunning.",(int)parg->worker_id);
83. srand(parg->worker_id*2);
84. sleep(rand()%5);
86. rend_wait(parg->prend);/*workersrendezvous*/
88. err_msg("worker#%dexiting.",(int)parg->worker_id);
90. returnEXIT_SUCCESS;
91. }
93. intmain(void){
94. intidx=0;
95. void*exitcode=NULL;
97. pthread_tthds[THREAD_COUNT];
98. structworker_argarg[THREAD_COUNT];
99. DECLARE_REND(rend,THREAD_COUNT);
101. err_msg("workerscreating.");
103. for(idx=0;idx<THREAD_COUNT;idx++){
104. arg[idx].prend=&rend;
105. arg[idx].worker_id=idx;
107. if(pthread_create(thds+idx,NULL,pthread_worker,(void*)&arg[idx]))
108. err_sys("worker#%dcreateerror.",idx);
109. }
111. puts("workersexiting.");
113. for(idx=0;idx<THREAD_COUNT;idx++)
114. if(pthread_join(thds[idx],&exitcode)||(exitcode!=EXIT_SUCCESS))
115. err_msg("worker#%dexiterror.",idx);
117. err_msg("alldone.exit0.");
119. rend_free(&rend);
121. returnEXIT_SUCCESS;
122. }

/*
 ==============================
 Name        : rendezvous.c
 Author      : liuzy (lzy.dev@gmail.com)
 Version     : 0.1
==============================
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>		/* va_list */
#include <unistd.h>
#include <string.h>
#include <errno.h>		/* errno */
#include <syslog.h>		/* for syslog(2) and level */
#include <pthread.h>

#include "rend.h"

static int daemon_proc = 0;	/* for syslog in err_doit */

#define	MAXLINE 4096		/* max text line length */

void err_doit(int errnoflag, int level, const char* fmt, va_list ap) {

	char buf[MAXLINE + 1] = { 0 };
	int errno_save = errno, n = 0;

#ifdef HAVE_VSNPRINTF
	vsnprintf(buf, MAXLINE, fmt, ap);
#else
	vsprintf(buf, fmt, ap);
#endif	/* HAVE_VSNPRINTF */

	n = strlen(buf);
	if (errnoflag)
		snprintf(buf + n, MAXLINE - n, ": %s", strerror(errno_save));
	strcat(buf, "/n");

	if (daemon_proc) {
		syslog(level, "%s", buf);
	} else {
		fflush(stdout);
		fputs(buf, stderr);
		fflush(stderr);
	}

	return;
}

void err_msg(const char* fmt, ...) {
	va_list ap;

	va_start(ap, fmt);
	err_doit(0, LOG_INFO, fmt, ap);
	va_end(ap);

	return;
}

void err_sys(const char* fmt, ...) {
	va_list ap;

	va_start(ap, fmt);
	err_doit(1, LOG_ERR, fmt, ap);
	va_end(ap);

	exit(EXIT_FAILURE);
}

#define THREAD_COUNT 100	/* rendezvous test thread workers */

struct worker_arg {
	int worker_id;
	struct rend_t* prend;
};

static void* pthread_worker(void* arg) {
	struct worker_arg* parg = (struct worker_arg*) arg;

	err_msg("worker #%d running.", (int) parg->worker_id);

	srand(parg->worker_id * 2);
	sleep(rand() % 5);

	rend_wait(parg->prend);	/* workers rendezvous */

	err_msg("worker #%d exiting.", (int) parg->worker_id);

	return EXIT_SUCCESS;
}

int main(void) {
	int idx = 0;
	void* exitcode = NULL;

	pthread_t thds[THREAD_COUNT];
	struct worker_arg arg[THREAD_COUNT];
	DECLARE_REND(rend, THREAD_COUNT);

	err_msg("workers creating.");

	for (idx = 0; idx < THREAD_COUNT; idx++) {
		arg[idx].prend = &rend;
		arg[idx].worker_id = idx;

		if (pthread_create(thds + idx, NULL, pthread_worker, (void*) &arg[idx]))
			err_sys("worker #%d create error.", idx);
	}

	puts("workers exiting.");

	for (idx = 0; idx < THREAD_COUNT; idx++)
		if (pthread_join(thds[idx], &exitcode) || (exitcode != EXIT_SUCCESS))
			err_msg("worker #%d exit error.", idx);

	err_msg("all done. exit 0.");

	rend_free(&rend);

	return EXIT_SUCCESS;
}

看了下 semaphore os syscall 及其 infrastructure，也许以后还需要进程间（非 pthread）集结时用得上。kernel 实现的超强啊，呵呵～

// 2009.11.17 14:34 添加 ////

快速用户空间互斥锁（Futex）

快速用户空间互斥锁（fast userspace mutex，Futex）是快速的用户空间的锁，是对传统的System V同步方式的一种替代，传统同步方式如：信号量、文件锁和消息队列，在每次锁访问时需要进行系统调用。而futex仅在有竞争的操作时才用系统调用访问内核，这样，在竞争出现较少的情况下，可以大幅度地减少工作负载
futex在非竞争情况下可从用户空间获取和释放，不需要进入内核。与信号量类似，它有一个可以原子增减的计数器，进程可以等待计数器值变为正数。用户进程通过系统调用对资源的竞争作一个公断。
futex 是一个用户空间的整数值，被多个线程或进程共享。Futex的系统调用对该整数值时进行操作，仲裁竞争的访问。 glibc中的NPTL库封装了futex 系统调用，对futex接口进行了抽象。用户通过NPTL库像传统编程一样地使用线程同步API函数，而不会感觉到futex的存在。
futex 的实现机制是：如果当前进程访问临界区时，该临界区正被另一个进程使用，当前进程将锁用一个值标识，表示“有一个等待者正挂起”，并且调用 sys_futex(FUTEX_WAIT)等待其他进程释放它。内核在内部创建futex队列，以便以后与唤醒者匹配等待者。当临界区拥有者线程释放了 futex，它通过变量值发出通知表示还有多个等待者在挂起，并调用系统调用sys_futex(FUTEX_WAKE)唤醒它们。一旦所有等待者已获取资源并释放锁时，futex回到非竞争状态，并没有内核状态与它相关。
robust futex是为了解决futex锁崩溃而对futex进行了增强。例如：当一个进程在持有pthread_mutex_t锁正与其他进程发生竞争时，进程因某种意外原因而提前退出，如：进程发生段错误，或者被用户用shell命令kill -9-ed”强行退出，此时，需要有一种机制告诉等待者“锁的最一个持有者已经非正常地退出”。“
为了解决此类问题，NPTL创建了robust mutex用户空间API pthread_mutex_lock()，如果锁的拥有者进程提前退出，pthread_mutex_lock()返回一个错误值，新的拥有者进程可以决定是否可以安全恢复被锁保护的数据。

有几点不还不理解：

1. “futex 如果说是一个用户空间的整数值，那怎么被多个进程共享？Futex 系统调用在 kernel 态怎么操作该值并仲裁竞争？这是那种直接映射到 userspace 的 kernel 地址么。这个需要程序间通过 mmap 在共享段中访问，与 futex 没什么关系。
2. 这个“robust futex”机制指的应该就是 SVRx 传统 sem IPC 里的 SEM_UNDO flag 吧？

一篇不错的文章，引发对 glibc nptl 实现源码的探索：

关于信号量与线程互斥锁的区别与实现