一步一步学习Unix编程[3]——并发服务器介绍与实现

转载请注明t1234xy4原创：http://blog.csdn.net/t1234xy4/article/details/51925409

1、理论解释

并发服务器：服务器能同时接受多个客服请求。即：服务器能同时服务多个客服，与客户端A链接的同时，还能链接客户端B。

相比迭代服务器并发服务器更优。

2、基础介绍

#include <unistd.h>

pid_t fork(void)  创建一个子进程。该进程执行一次返回两次。 返回 值等于0 为子进程，返回值大于0为父进程，小于0 fork失败。其中大于0的值，是子进程的Id。

fork出来的子进程为父进程的副本，即与父进程一样，有相同的资源和空间。子进程的创建过程中，需要复制父类中的资源与空间，比较耗时，有一种写时复制的机制，此处不做讨论。

为了让迭代服务器变成并发服务器，我们让服务器端父进程只做监听工作，具体与客户端的交互交由子进程处理。

子进程处理完任务后，不做处理，将会变成僵死进程。僵死进程，占有资源（内存，CPU、文件描述符等），如果不终止它，最终会耗尽资源。

所以所有的父进程都因该wait子进程，以防止子进程编程僵死进程。我们可以通过信号函数监督父进程的子进程状态，当有子进程返回时，通过信号函数处理。

信号函数：

void (*signal(int signo, void(*func)(int) ))(int);

函数传入一个整型signo和一个函数指针，void (*func)(int )。

关于wait 与waitpid 介绍 见 http://blog.csdn.net/t1234xy4/article/details/51921225

3、并发服务器原型

依照迭代的过程，我们把accept后建立的链接交给子进程处理，父进程接着监听，就变成了并发服务器。

因此只需要在accept后添加fork，把处理函数放在子进程中。

并发服务器源码：

/*
 * ServiceFork.cpp
 *
*  Created on: Jul 15, 2016
 *      Author: ubuntu
 */
#include <iostream>
#include "MyIncluding.h"
#include <sys/signal.h>
#include <wait.h>

using namespace std;
char serv_ip[16] = "172.25.9.94";

void sig_chld(int signo) 
{
	int stat;
	pid_t pid;
	while(  (pid = waitpid(-1,&stat,WNOHANG)) > 0   )  //此处不应该阻塞，因此设置WNOHANG
		cout << "child "<<pid << "terminated"<<endl;
	return ;
}

int main(int argc,char** argv)
{
	int listenfd,connfd;
	pid_t childpid;
	struct sockaddr_in cliaddr,servaddr;

	bzero(&servaddr,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	inet_pton(AF_INET,serv_ip,&servaddr.sin_addr);
	servaddr.sin_port = htons(SERV_PORT);

	listenfd = socket(AF_INET,SOCK_STREAM,0);

	int nbind = bind(listenfd,(SA *)&servaddr,sizeof(servaddr));

	int nlisten = listen(listenfd,LISTENQ);

	signal(SIGCHLD,sig_chld); //捕获<span style="color: rgb(51, 51, 51); font-family: arial, 宋体, sans-serif; font-size: 14px; line-height: 24px; text-indent: 28px;">SIGCHLD信号，做sig_chld处理。</span>

	while(1)
	{
		socklen_t cliaddrlen= sizeof(cliaddr);
		connfd = accept(listenfd,(SA *)&cliaddr,&cliaddrlen);
		if(connfd<0)
		{
			if(errno == EINTR)
				continue;
			else
				cout <<"accept error!"<<endl;
		}

		if( (childpid = fork()) == 0 ){
			close(listenfd); //fork后子进程是父进程的副本，此处应该关闭，减少不用资源。
			char buff[1024];
			int nread = read(connfd,buff,sizeof(buff));
			if( nread > 0 )
				cout<< "receive MSG:"<<buff<<endl;
			exit(0);
		}
		close(connfd); //子进程关闭处理完的链接套接字
	}

}

SIGCHLD信号：在一个进程终止或者停止时，将SIGCHLD信号发送给其父进程。

4、修改客服端

我们增加了一个ClientThread类public继承 SinClient类。

ClientThread.h

/*
 * ClientThread.h
 *
 *  Created on: Jul 14, 2016
 *      Author: ubuntu
 */

#ifndef CLIENTTHREAD_H_
#define CLIENTTHREAD_H_

#include "SimClient.h"

class ClientThread: public SimClient {
public:
	ClientThread();
	int getThreadId(){return (int) _threadId;}
	void setThreadId(int Id){ _threadId = Id;}
	virtual bool  run();
	virtual ~ClientThread();

private:
	pid_t _threadId;
};

#endif /* CLIENTTHREAD_H_ */

我们只从写了run()函数，其他的使用SimClient。

ClientThread.cpp

/*
 * ClientThread.cpp
 *
 *  Created on: Jul 14, 2016
 *      Author: ubuntu
 */

#include "ClientThread.h"
ClientThread::ClientThread():_threadId(-1){
	// TODO Auto-generated constructor stub
}

bool ClientThread::run()
{
	char msg[1024];
	time_t ticks = time(NULL);
	snprintf(msg,sizeof(msg),"client %d access at: %.24s",_threadId,ctime(&ticks));
	int nwrite = write(sockfd,msg,strlen(msg));
	if(nwrite < 0)
		cout << "Message send failure ************"<<endl;
	else
		cout << "Message: "<<msg << ", sended!"<<endl;
	return true;
}


ClientThread::~ClientThread() {
	// TODO Auto-generated destructor stub
}

我们把客户端的ID以及本地时间传给服务器。

客户端如后函数，我们建立1000个客户端同时链接服务器。

//============================================================================
// Name        : SimClient.cpp
// Author      : Tian
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include "SimClient.h"
#include "ClientThread.h"
using namespace std;

int main(int argc,char** argv) {
	cout << "!!!!!!thread Test is running!!!!!!" << endl; 
	sleep(1);
	ClientThread *thread[1000];;
	for(int i=0;i<1000;i++)
	{
		thread[i] = new ClientThread;
		thread[i]->setThreadId(i);
		if (!thread[i]->connectServer())
			{
				cout << "thread "<< i << "failed!"<<endl;
				continue;
			}
		cout << endl <<"connected :"<< thread[i]->getThreadId()<<endl;
		thread[i]->run();
		cout << thread[i]->getThreadId() <<" shutdown !";
	}

	delete[] thread;
	return 0;
}

结果：

我们先运行服务器端程序，让服务器端处于监听状态。

然后我们运行客户端程序。

客户端运行结果：我们建立了0～999个链接，此处只给出了最后几个连接。

服务器端：

服务器端接收到客服端的消息，当子进程处理完后调用sig_chld函数处理。

并发服务器注意：

1、子进程是父进程的副本，进入子进程后需要关闭监听端口，减少子进程开销。同时退出时需要close掉子进程中的接收数据用的端口。

2、注意父进程需要等待子进程处理结束，以防止子进程变成僵死进程。使用waitpid，因为子进程较多，不能阻塞，需要设置waitpid为WNOHANG。

3、使用信号处理子进程，因为子进程结束后都会给父进程发送SIGCHLD信号，可以在此信号中调用waitpid。