UNIX网络编程卷1 回射客户程序 TCP客户程序设计范式

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie

下面我会介绍同一个使用 TCP 协议的客户端程序的几个不同版本,分别是停等版本、select 加阻塞式 I/O 版本、

非阻塞式 I/O 版本、fork 版本、线程化版本。它们都由同一个 main 函数调用来实现同一个功能,即回射程序客户端。

它从标准输入读入一行文本,写到服务器上,读取服务器对该行的回射,并把回射行写到标准输出上。

其中,非阻塞式 I/O 版本是所有版本中执行速度最快的,但它的代码比较复杂。

创建一个新线程通常比使用 fork 派生一个新进程快得多,

下面代码中的线程化版本执行速度略快于 fork版本,稍慢于非阻塞式 I/O。一般编程推荐使用线程版本。

下面是《Unix 网络编程:卷1》中给出的各个版本的性能测试结果:

354.0秒,停等版本

12.3秒, select加阻塞式I/O版本

6.9秒,  非阻塞式I/O版本

8.7秒, fork 版本

8.5秒,  线程化版本

下面是 main 函数的代码

#include	"unp.h"

int
main(int argc, char **argv)
{
	int					sockfd;
	struct sockaddr_in	servaddr;

	if (argc != 2)
		err_quit("usage: tcpcli <IPaddress>");

	//1.创建 TCP 套接字
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);

	//2.指定服务器的 IP 地址和端口
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	//3.建立与服务器的连接
	Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));

	//4.str_cli 函数完成剩余部分的客户处理工作
	str_cli(stdin, sockfd);		

	exit(0);
}

最初代码(停等版本):

#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
	char	sendline[MAXLINE], recvline[MAXLINE];

	//1.从 fp 读入一行,存放到 sendline
	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		//2.将 sendline 的内容写到 sockfd 连接的服务器
		Writen(sockfd, sendline, strlen(sendline));

		//3.从服务器读入回射行,存放到 recvline
		if (Readline(sockfd, recvline, MAXLINE) == 0)
			err_quit("str_cli: server terminated prematurely");

		//4.将 recvline 的内容写到标准输出
		Fputs(recvline, stdout);
	}
}

问题1:当套接字上发生某些事件时,客户可能阻塞于 fgets 调用

改善1:使用 select 重写 str_cli 函数,阻塞于 select 调用,或是等待标准输入可读,

或是等待套接字可读。这样服务器一终止,客户就能马上得到通知。

/**
* TCP 使用 select
**/
#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
	int			maxfdp1; //  maxfdpl 参数指定待测定的描述符个数
	fd_set		rset;   //可读描述符集合
	char		sendline[MAXLINE], recvline[MAXLINE];

	//1.调用 select
	FD_ZERO(&rset); //初始化 rset
	for ( ; ; ) {
		FD_SET(fileno(fp), &rset); // 打开标准I/O文件指针 fp 对应的位
		FD_SET(sockfd, &rset); 	  // 打开套接字 sockfd 对应的位
		maxfdp1 = max(fileno(fp), sockfd) + 1;
		//调用 select 阻塞到某个描述符就绪为止
		Select(maxfdp1, &rset, NULL, NULL, NULL);

		//2.处理可读套接字
		if (FD_ISSET(sockfd, &rset)) {
			//使用 readline 读入回射文本,再用 fputs 输出到 stdout
			if (Readline(sockfd, recvline, MAXLINE) == 0)
				err_quit("str_cli: server terminated prematurely");
			Fputs(recvline, stdout);
		}

		//3.处理可读输入
		if (FD_ISSET(fileno(fp), &rset)) {
			//使用 fgets 读入一行文本,再用 writen 把它写到套接字中
			if (Fgets(sendline, MAXLINE, fp) == NULL)
				return;		/* all done */
			Writen(sockfd, sendline, strlen(sendline));
		}
	}
}

改善1的问题:批量方式运行用 select 编写的回射客户程序,发现即使已经遇到了用户输入结尾,

仍可能有数据处于运往或来自服务器的管道中。

改善2(select加阻塞式I/O版本):使用 shutdown 函数利用上 TCP 的半关闭特性

下面代码使用了 select 和 shutdown,前者只要服务器关闭它那一端的连接就会通知客户,

后者允许客户正确地处理批量输入。这个版本还废弃了以文本行为为中心的代码,发布针对缓冲区操作。

/**
* TCP 使用 select 并操纵缓冲区
**/
#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
	//stdineof 表示标准输入是否结束
	int			maxfdp1, stdineof;
	fd_set		rset;
	char		buf[MAXLINE];
	int		n;

	//1.调用 select
	stdineof = 0;
	FD_ZERO(&rset);
	for ( ; ; ) {
		if (stdineof == 0)
			FD_SET(fileno(fp), &rset);
		FD_SET(sockfd, &rset);
		maxfdp1 = max(fileno(fp), sockfd) + 1;
		Select(maxfdp1, &rset, NULL, NULL, NULL);

		//2.处理可读套接字
		if (FD_ISSET(sockfd, &rset)) {	/* socket is readable */
			if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
				if (stdineof == 1) //如果在套接字上读到 EOF,并且已在标准输入上遇到 EOF,那就是正常的终止
					return;
				else //否则,服务器进程过早终止了
					err_quit("str_cli: server terminated prematurely");
			}

			Write(fileno(stdout), buf, n);
		}

		//3.处理可读输入
		if (FD_ISSET(fileno(fp), &rset)) {
			//如果在标准输入上碰到 EOF 时,把 stdineof 置为 1
			//并调用 shutdown 函数向服务器发送 FIN,关闭客户端向服务器的写操作
			if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) {
				stdineof = 1;
				Shutdown(sockfd, SHUT_WR);
				FD_CLR(fileno(fp), &rset);
				continue;
			}

			Writen(sockfd, buf, n);
		}
	}
}

改善2问题:阻塞式I/O

例如,如果在标准输入有一行文本可读,我们就调用 read 读入它,再调用  writen 把它发送给服务器。

然而如果套接字发送缓冲区已满, writen 调用将会阻塞。在进程阻塞于 writen 调用期间,可能有来自套接字接收缓冲区的数据可供读取。

类似的,如果从套接字有一行输入文本可读,那么一旦标准输出比网络还要慢,进程照样可能阻塞于后续的 write 调用。

改善3(非阻塞式I/O版本):使用非阻塞式 I/O

/* include nonb1 */
#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
	int			maxfdp1, val, stdineof;
	ssize_t		n, nwritten;
	fd_set		rset, wset;
	char		to[MAXLINE], fr[MAXLINE];
	//to 容纳从标准输入到服务器去的数据
	//from 容纳自服务器到标准输出来的数据
	char		*toiptr, *tooptr, *friptr, *froptr;

	//1.把描述符设置为非阻塞
	val = Fcntl(sockfd, F_GETFL, 0);
	Fcntl(sockfd, F_SETFL, val | O_NONBLOCK); //套接字描述符

	val = Fcntl(STDIN_FILENO, F_GETFL, 0);
	Fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK); //标准输入

	val = Fcntl(STDOUT_FILENO, F_GETFL, 0);
	Fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK); //标准输出

	//2.初始化缓冲区指针
	toiptr = tooptr = to;
	friptr = froptr = fr;
	stdineof = 0;
	maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;

	//3.主循环:调用 select
	//一个 select 调用后对所关注各个条件进行单独测试
	for ( ; ; ) {
		//指定所关注的描述符
		FD_ZERO(&rset);
		FD_ZERO(&wset);
		if (stdineof == 0 && toiptr < &to[MAXLINE])
			FD_SET(STDIN_FILENO, &rset);	/* 打开读描述符集中对应标准输入的位 */
		if (friptr < &fr[MAXLINE])
			FD_SET(sockfd, &rset);			/* 打开读描述符集中对应套接字的位 */
		if (tooptr != toiptr)
			FD_SET(sockfd, &wset);			/* 打开写描述符集中对应套接字的位 */
		if (froptr != friptr)
			FD_SET(STDOUT_FILENO, &wset);	/* 打开写描述符集中对应标准输出的位 */
		//调用 select
		Select(maxfdp1, &rset, &wset, NULL, NULL);
/* end nonb1 */
/* include nonb2 */
		//4.对所关注各个条件进行单独测试
		//从标准输入 read
		if (FD_ISSET(STDIN_FILENO, &rset)) {
			//read 返回错误。 EWOULDBLOCK 是正常的错误,表明这个描述符还处在阻塞中,应该忽略该错误
			if ( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("read error on stdin");

			}
			//read 返回 EOF,标准输入处理结束
			else if (n == 0) {
#ifdef	VOL2
				fprintf(stderr, "%s: EOF on stdin\n", gf_time());
#endif
				stdineof = 1;			/* 标志标准输入结束 */
				if (tooptr == toiptr)   // to 缓冲区中已经没有数据要发送
					Shutdown(sockfd, SHUT_WR);/* 关闭客户端向服务器的写操作 */

			}
			//read 返回数据
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
#endif
				toiptr += n;			//增加 toiptr
				FD_SET(sockfd, &wset);	//打开写描述符集中对应套接字的位
			}
		}

		//从套接字 read
		if (FD_ISSET(sockfd, &rset)) {
			//read 返回错误。 EWOULDBLOCK 是正常的错误,表明这个描述符还处在阻塞中,应该忽略该错误
			if ( (n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("read error on socket");

			}
			//read 返回 EOF,服务器返回数据结束
			else if (n == 0) {
#ifdef	VOL2
				fprintf(stderr, "%s: EOF on socket\n", gf_time());
#endif
				if (stdineof) //如果遇到来自服务器的 EOF ,并且已经在标准输入上遇到 EOF ,则正常结束;否则就是服务器过早终止了
					return;		/* normal termination */
				else
					err_quit("str_cli: server terminated prematurely");

			}
			//read 返回数据
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: read %d bytes from socket\n",
								gf_time(), n);
#endif
				friptr += n;		//增加 friptr
				FD_SET(STDOUT_FILENO, &wset);	// 打开写描述符集中对应标准输出的位
			}
		}
/* end nonb2 */
/* include nonb3 */
		//write 到标准输出
		if (FD_ISSET(STDOUT_FILENO, &wset) && ( (n = friptr - froptr) > 0)) {
			//write 返回错误。
			if ( (nwritten = write(STDOUT_FILENO, froptr, n)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("write error to stdout");

			}
			//write 成功
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: wrote %d bytes to stdout\n",
								gf_time(), nwritten);
#endif
				froptr += nwritten;		//增加写出字节数
				if (froptr == friptr)
					froptr = friptr = fr;	//如果输出指针追上输入指针, 这两个指针不同时恢复为指向缓冲区开始处
			}
		}

		//write 到套接字
		if (FD_ISSET(sockfd, &wset) && ( (n = toiptr - tooptr) > 0)) {
			//write 失败
			if ( (nwritten = write(sockfd, tooptr, n)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("write error to socket");

			}
			//write 成功
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: wrote %d bytes to socket\n",
								gf_time(), nwritten);
#endif
				tooptr += nwritten;
				if (tooptr == toiptr) { //
					toiptr = tooptr = to;
					if (stdineof) //如果标准输入已经读完,并且已经缓冲区的数据都已经发送给服务器,就关闭写套接字
						Shutdown(sockfd, SHUT_WR);	/* send FIN */
				}
			}
		}
	}
}
/* end nonb3 */

改善3问题:非阻塞式版本比较复杂

改善4:需要使用非阻塞I/O时,更简单的方法是把应用程序任务划分到多个进程(使用 fork) 或多个线程

fork 版本:

/**
* TCP 使用两个进程 (fork)
**/
#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
	pid_t	pid;
	char	sendline[MAXLINE], recvline[MAXLINE];

	//子进程:从服务器读取数据并输出到 stdout
	if ( (pid = Fork()) == 0) {
		while (Readline(sockfd, recvline, MAXLINE) > 0)
			Fputs(recvline, stdout);

		kill(getppid(), SIGTERM);	/* 子进程向父进程发送一个 SIGTERM 信号,终止父进程 */
		exit(0);
	}

	//父进程:从 stdin 读取数据并发送到服务器
	while (Fgets(sendline, MAXLINE, fp) != NULL)
		Writen(sockfd, sendline, strlen(sendline));

	//在 stdin 读取 EOF,输入结束,关闭写套接字
	Shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */

	//父进程完成数据凰调用 pause 让自己进入睡眠状态
	pause();
	return;
}

线程化版本:

/**
* TCP 使用两个线程
**/
#include	"unpthread.h"

void	*copyto(void *);

static int	sockfd;		/* global for both threads to access */
static FILE	*fp;

void
str_cli(FILE *fp_arg, int sockfd_arg)
{
	char		recvline[MAXLINE];
	pthread_t	tid;

	//1.把参数保存在外部变量中
	sockfd = sockfd_arg;	/* copy arguments to externals */
	fp = fp_arg;

	//2.创建新线程
	Pthread_create(&tid, NULL, copyto, NULL);

	//3.主线程循环:从套接字到标准输出复制
	while (Readline(sockfd, recvline, MAXLINE) > 0)
		Fputs(recvline, stdout);
}

//4.copyto 线程:从标准输入到套接字复制
void *
copyto(void *arg)
{
	char	sendline[MAXLINE];

	while (Fgets(sendline, MAXLINE, fp) != NULL)
		Writen(sockfd, sendline, strlen(sendline));

	Shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */

	return(NULL);
		/* 4return (i.e., thread terminates) when EOF on stdin */
}

时间: 08-23

UNIX网络编程卷1 回射客户程序 TCP客户程序设计范式的相关文章

UNIX网络编程卷1 回射服务器程序 TCP服务器程序设计范式 四个版本

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 这是一个简单的回射服务器程序.它将客户发送的数据读入缓冲区并回射其中内容 下面我会介绍同一个使用 TCP 协议的回射服务器程序的几个不同版本,分别是 fork 版本.select 版本.poll 版本.多线程版本 fork 版本:为每一个客户连接派生(fork) 一个子进程用来处理客户请求 /** * TCP/IPv4 协议相关 * **/ #include "unp.h" in

UNIX网络编程卷1 回射客户程序 UDP 超时设置

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 最初代码: #include "unp.h" int main(int argc, char **argv) { int sockfd; struct sockaddr_in servaddr; if (argc != 2) err_quit("usage: udpcli <IPaddress>"); //1.指明服务器的 IP 地址和端口 bze

UNIX网络编程卷1 时间获取程序server TCP 协议相关性

本文为senlie原创.转载请保留此地址:http://blog.csdn.net/zhengsenlie 最初代码: 这是一个简单的时间获取server程序.它和时间获取程序client一道工作. 它是 协议相关,把代码中出现的左边的字符串换为右边的,就变成了IPv6版本号的 IPv4 --> IPv6 sockaddr_in --> sockaddr_in6 AF_INET --> AF_INET6 sin_family --> sin6_family sin_port --&

UNIX网络编程 第1章:简介和TCP/IP

1.1 按1.9节未尾的步骤找出你自己的网络拓扑的信息. 1.2 获取本书示例的源代码(见前言),编译并测试图1-5所示的TCP时间获取客户程序.运行这个程序若干次,每次以不同IP地址作为命令行参数. 1.3 把图1-5中的socket的第一参数改为9999.编译并运行这个程序.结果如何?找出对应于所输出出错的errno值.你如何可以找到关于这个错误的更多信息? socket error: Address family not supported by protocol 1.4 修改图1-5中的

UNIX网络编程卷1 服务器程序设计范式1 并发服务器,为每个客户请求fork一个进程

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.传统并发服务器调用 fork 派生一个子进程来处理每个客户 2.传统并发服务器的问题在于为每个客户现场 fork 一个子进程比较耗费 CPU 时间. /* include serv01 */ #include "unp.h" int main(int argc, char **argv) { int listenfd, connfd; pid_t childpid; void

UNIX网络编程卷1 服务器程序设计范式0 迭代服务器

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.迭代 TCP 服务器总是在完全处理某个客户的请求后才转向下一个客户. 2.从进程控制角度看迭代服务器是最快的,因为它不执行进程控制. /* include serv00 */ #include "unp.h" int main(int argc, char **argv) { int listenfd, connfd; void sig_int(int), web_child

unix网络编程卷1:套接字联网 源码编译

QUICK AND DIRTY Execute the following from the src/ directory: 一: ./configure # try to figure out all 结果是: ........ checking for struct addrinfo... yes checking for struct if_nameindex... yes checking for struct sockaddr_dl... no checking for struct

UNIX网络编程卷1 server编程范式0 迭代server

本文senlie原版的.转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.迭代 TCP server总是在全然处理某个客户的请求后才转向下一个客户. 2.从进程控制角度看迭代server是最快的,由于它不运行进程控制. /* include serv00 */ #include "unp.h" int main(int argc, char **argv) { int listenfd, connfd; void sig_int(int), web

UNIX网络编程1.1概述 1.2时间获取客户函数 1.4错误处理包裹函数

逻辑上socket处于应用层与传输层之间. ip,端口,协议,一起决定了网络的一个端点. #include <iostream> #include "unp.h" int main(int argc, char** argv) { int sockfd; int n; char recvline[MAXLINE + 1]; struct sockaddr_in servaddr; if (argc != 2) { err_quit("usage: a.out &l