客户端、服务器端编程

首先是从main函数开发：

int main(itn argc,char* argv[])
{
pthread_t thread;
int count;
int status;
        client_threads = CLIENT_THREADS;
for(count = 0;count <client_threads,count++)
{
status = pthread_create(&thread,NULL,client_routine,(void*)count);
if(status != 0)
err_abort(status,"Create client thread");
}
status = pthread_mutex_lock(&client_mutex);
if(status != 0)
err_abort(status,"Lock client mutex");
while(client_threads>0)
{
status = pthread_cond_wait(&clients_done,&client_mutex);
if(status != 0)
err_abort(status,"Wait for client to finish");
}
status = pthread_mutex_unlock(&client_mutex);
if(status != 0)
err_abort(status,"Unlock client mutex");
printf("All client done\n");
tty_server_request(REQ_QUIT,1,NULL,NULL);
return 0;
}

这个main函数在中间for循环中，调用pthread_create函数创建4个线程，传递给线程的数据位count(0,1,2,3).调用client_routine函数。

void *client_routine(void *arg)
{
int my_number = (int)arg,loops;
char prompt[32];
char string[128],formatted[128];
int status;
sprintf(prompt,"Client 5d>",my_number);
while(1)
{
tty_server_request(REQ_READ,1,prompt,string);
if(strlen(string) ==0)
break;
for(loops =0;loops <4;loops++)
{
sprintf(formatted,"(%d#%d)%s",my_number,loops,string);
tty_server_request(REQ_WRITE,0,NULL,formatted);
sleep(1);
}
}
status = pthread_mutex_lock(&client_mutex);
if(status != 0)
err_abort(status,"Lock client mutex");
client_threads--;
if(client_threads <= 0)
{
status = pthread_cond_signal(&clients_done);
if(status != 0)
err_abort(status,"Signale client done");
}
status = pthread_mutex_unlock(7client_mutex);
if(status != 0)
err_abort(status,"Unlock client mutex");
return NULL;
}

pthread_cond_wait() 用于阻塞当前线程，等待别的线程使用pthread_cond_signal()或pthread_cond_broadcast来唤醒它。 pthread_cond_wait() 必须与pthread_mutex 配套使用。pthread_cond_wait()函数一进入wait状态就会自动release mutex。当其他线程通过pthread_cond_signal()或pthread_cond_broadcast，把该线程唤醒，使pthread_cond_wait()通过（返回）时，该线程又自动获得该mutex。

  pthread_cond_signal函数的作用是发送一个信号给另外一个正在处于阻塞等待状态的线程,使其脱离阻塞状态,继续执行.如果没有线程处在阻塞等待状态,pthread_cond_signal也会成功返回。

  使用pthread_cond_signal一般不会有“惊群现象”产生，他最多只给一个线程发信号。假如有多个线程正在阻塞等待着这个条件变量的话，那么是根据各等待线程优先级的高低确定哪个线程接收到信号开始继续执行。如果各线程优先级相同，则根据等待时间的长短来确定哪个线程获得信号。但无论如何一个pthread_cond_signal调用最多发信一次。

  但是pthread_cond_signal在多处理器上可能同时唤醒多个线程，当你只能让一个线程处理某个任务时，其它被唤醒的线程就需要继续 wait，而且规范要求pthread_cond_signal至少唤醒一个pthread_cond_wait上的线程，其实有些实现为了简单在单处理器上也会唤醒多个线程. 

   另外，某些应用，如线程池，pthread_cond_broadcast唤醒全部线程，但我们通常只需要一部分线程去做执行任务，所以其它的线程需要继续wait.所以强烈推荐对pthread_cond_wait() 使用while循环来做条件判断.

在这里如果没有线程，则通知等待创建线程唤醒wait在此条件变量上的等待。

上面全部代码：

#include <pthread.h>
#include <math.h>
#include "errors.h"


#define CLIENT_THREADS 4


#define REQ_READ 1
#define REQ_WRITE 2
#define REQ_QUIT 3


typedef struct request_tag
{
struct request_tag *next;
int operation;
int synchronous;
int done_flag;
pthread_cond_t done;
char prompt[32];
char text[128];
}request_t;


typedef struct tty_server_tag
{
request_t *first;
request_t *last;
int running;
pthread_mutex_t mutex;
pthread_cond_t request;
}tty_server_t;


tty_server_t tty_server = 
{
NULL,NULL,0,PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER
};


int client_threads;
pthread_mutex_t client_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t clients_done = PTHREAD_COND_INITIALIZER;


void *tty_server_routine(void *arg)
{
static pthread_mutex_t prompt_mutex = PTHREAD_MUTEX_INITIALIZER;
request_t *request;
int operation,len;
int status;
while(1)
{
status = pthread_mutex_lock(&tty_server.mutex);
if(status != 0)
err_abort(status,"Lock server mutex");
while(tty_server.first ==NULL)
{
status = pthread_cond_wait(&tty_server.request,&tty_server.mutex);
if(status != 0)
{
err_abort(status,"Wait for request");
}
request = tty_server.first;
tty_server.first= request->next;
if(tty_server.first == NULL)
{
tty_server.last = NULL;
}
status = pthread_mutex_unlock(&tty_server.mutex);
if(status != 0)
err_abrort(status,"Unlock server mutex");
operation = request->operation;
switch(operation)
{
case REQ_QUIT:
break;
case REQ_READ:
if(strlen(request->prompt)>0)
printf(request->prompt);
if(fgets(request->text,128,stdin)==NULL)
request->text[0]='\0';
len = strlen(request->text);
if(len>0&&request->text[len-1]=='\n')
request->text[len-1]='\0';
break;
case REQ_WRITE:
puts(request->text);
break;
default:
break;
}
if(request->synchronous)
{
status = pthread_mutex_lock(&tty_server.mutex);
if(status != 0)
err_abort(status,"Lock server mutex");
request->done_flag =1;
status = pthread_cond__signal(&request->done);
if(status != 0)
err_abort(status,"Unlock server mutex");
}else
free(request);
if(operation ==REQ_QUIT)
break;
}
return NULL;
}


void tty_server_request(int operation,int sync,const char* prompt,char* string)
{
request_t *request;
int status;


status =pthread_mutex_lock(&tty_server.mutex);
if(status != 0)
err_abort(status,"Lock server mutex");
if(!tty_server.running)
{
pthread_t thread;
pthread_attr_t detached_attr;


status = pthread_attr_init(&detached_attr);
if(status != 0)
err_abort(status,"Init attributes object");
status = pthread_attr_setdetachstate(&detached_attr,PTHREAD_CREATE_DETACHED);
if(status != 0)
err_abort(status,"Set detach state");
tty_server.running = 1;
status = pthread_create(&thread,&detached_attr,tty_server_routine,NULL);
if(status != 0)
err_abort(status,"Create server");
pthread_attr_destroy(&detached_attr);
}
request = (request_t*)malloc(sizeof(request_t));
if(request ==NULL)
errno_abort("Allocate Request");
request->next = NULL;
request->operation = operation;
request->synchronous = sync;
if(sync)
{
request->done_flag = 0;
status = pthread_cond_init(&request->done,NULL);
if(status != 0)
err_abort(status ,"Init request condition");
}
if(prompt != NULL)
strncpy(request->prompt,prompt,32);
else 
request->prompt[0]='\0';
if(operation == REQ_WRITE &&string != NULL)
strncpy(request->text,string,128);
else
request->text[0]='\0';
if(tty_server.first == NULL)
{
tty_server.first = request;
tty_server.last = request;
}else
{
(tty_server.last)->next = request;
tty_server.last= request;
}
status = pthread_cond_signal(&tty_server.request);
if(status != 0)
err_abort(status,"Wake server");
if(sync)
{
while(!request->done_flag)
{
status = pthread_cond_wait(&request->done,&tty_server.mutex);
if(status != 0)
err_abort(status,"Wait for sync request");
}
if(operation == REQ_READ)
{
if(strlen(request->text)>0)
strcpy(string,request->text);
else 
string[0]='\0';
}
status = pthread_cond_destroy(&request->done);
if(status != 0)
err_abort(status,"destroy request condition");
free(request);
}
status = pthread_mutex_unlock(&tty-server.mutex);
if(status != 0)
err_abort(status,"Unlock mutex");
}