多进程并发编程----基于高级的预先创建进程池(accept使用文件上锁)的模型

本篇博文讲解如何使用fcntl文件上锁的方式对accept进行保护。

如果多个进程在引用同一个监听套接字的描述符上调用accept，对于不同的内核accept不一定都是原子操作。Berkeley的内核支持这种模型，而system V就会出现问题，那么我们的解决方法之一就是本博文讲解的使用文件上锁保护accept函数调用，保证任意时刻只有一个进程阻塞在accept，其他进程则阻塞在试图获取用于保护accept的锁上。

客户端的程序参考上一篇博文的客户端程序：点击打开链接 http://blog.csdn.net/hnlyyk/article/details/51210143

服务端程序如下：

<span style="font-size:18px;">#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define PIDNUMB 5

struct flock lock,unlock;//lock用于加锁，unlock用于解锁
int lock_fd=-1;
void my_lock_init(char *pathname){
	char buf[256];
	sprintf(buf,"%s",pathname);
	if(mktemp(buf)!=NULL)//mktemp函数参数必须是字符数组
		if( (lock_fd=open(buf,O_CREAT|O_WRONLY,S_IRUSR)) < 0 )
			printf("open error:%s\n",strerror(errno));
	unlink(buf);//删除文件路径链接，但文件可以继续使用，因为打开的文件描述符引用计数大于0
	
	lock.l_type=F_WRLCK;
	lock.l_whence=SEEK_SET;
	lock.l_start=0;
	lock.l_len=0;

	unlock.l_type=F_UNLCK;
	unlock.l_whence=SEEK_SET;
	unlock.l_start=0;
	unlock.l_len=0;	
	
}
void my_lock_wait(){
	int ret;
	while( (ret=fcntl(lock_fd,F_SETLKW,&lock))<0 ){//使用fcntl函数设置锁类型lock
		if(errno==EINTR)
			continue;
		else
			printf("fcntl lock error:%s\n",strerror(errno));
	}
}
void my_lock_release(){
	if( fcntl(lock_fd,F_SETLKW,&unlock) <0 )//使用fcntl函数设置锁类型unlock
		printf("fcntl unlock error:%s\n",strerror(errno));
}
static void handle_connect(int s_s,int pid)
{	
	int s_c;	/*客户端套接字文件描述符*/
	struct sockaddr_in from;	/*客户端地址*/
	int len = sizeof(from);
	int count=0;
	/*主处理过程*/
	while(1)
	{
		printf("count[%d],pid[%d]\n",count,getpid());
		/*接收客户端连接*/
		my_lock_wait();//add write lock
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		my_lock_release();//release write lock
		if(s_c > 0)
			count++;
		time_t now;		/*时间*/
		char buff[BUFFLEN];/*收发数据缓冲区*/
		int n = 0;
		memset(buff, 0, BUFFLEN);/*清零*/
		n = recv(s_c, buff, BUFFLEN,0);/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);/*清零*/
			now = time(NULL);/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));/*将时间拷贝入缓冲区*/
			send(s_c, buff, strlen(buff),0);/*发送数据*/
			sleep(1);
		}		
		/*关闭客户端*/
		close(s_c);	
	}
		
}

void sig_int(int num)
{
	exit(1);	
}
int main(int argc, char *argv[])
{
	int s_s;	/*服务器套接字文件描述符*/
	struct sockaddr_in local;	/*本地地址*/	
	signal(SIGINT,sig_int);
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);

	int optval=1;
	int ret=setsockopt(s_s,SOL_SOCKET,SO_REUSEADDR,(int *)&optval,sizeof(optval));
	
	/*初始化地址接哦股*/
	memset(&local, 0, sizeof(local));/*清零*/
	local.sin_family = AF_INET;/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	int err = bind(s_s, (struct sockaddr*)&local, sizeof(local));
	err = listen(s_s, BACKLOG);/*侦听*/
	
	//init the write lock
	my_lock_init("/tmp/lock.XXXXXX");
	
	/*处理客户端连接*/
	pid_t pid[PIDNUMB];
	int i =0;
	for(i=0;i<PIDNUMB;i++)
	{
		pid[i] = fork();
		if(pid[i] == 0)/*子进程*/
		{			
//			printf("pid[%d]\n",getpid());
			handle_connect(s_s,getpid());
		}
	}
	while(1);
	
	close(s_s);
	
	return 0;		
}
</span>

注意：

优点是可以移植到所有兼容POSIX系统上使用

缺点是操作涉及文件系统，可能比较耗费时间。

下一篇我们讲解使用线程的mutex对accept加锁。