前言

一、套接字编程简介

1. 套接字地址结构

1. IPv4套接字地址结构

2. IPv6套接字地址结构

3. 通用套接字地址结构

2. Socket编程API

1. 字节序转换函数 htonl 和 ntohl

#include<netinet/in.h> 
// host -> net 主机字节序转为网络字节序
uint16_t htons(uint16_t host16bitvalue);
uint32_t htonl(uint32_t host32bitvalue);
// net -> host 网络字节序转为主机字节序
uint16_t ntohs(uint16_t net16bitvalue);
uint32_t ntohl(uint32_t net32bitvalue);

2. 字节操纵函数 bzero 等

#include <strings.h>
void bzero(void *dest, size_t nbytes);// 将目标设置为 0
void bcopy(const void *src, void *dest, size_t nbytes);
int bcmp(const void *ptrl, const void *ptr2, size_t nbytes);

#include<string.h>
void *memset(void *dest, int c, size_t len);
void *memcpy(void *dest,const void *src, size_t nbytes);
int memcmp(const void *ptrl, const void *ptr2, sise_t nbytes);

3. 地址转换函数 inet_pton 和 inet_ntop

#include <arpa/inet.h>
// 例:"206.168.112.96" -> struct in_addr(32bit IPv地址)
int inet_aton(const char *strptr, struct in_addr *addrptr);
 返回:字符串有效为 1,否则为 0
// 例:struct in_addr(32bit IPv地址)-> "206.168.112.96" 
char *inet_ntoa(struct in_addr inaddr);

#include <arpa/inet.h>
int inet_pton(int family, const char *strptr, void*addrptr);
const char *inet_ntop(int family, const void *addrptr, char *strptr, size_t len);

inet_pton(AF_INET, cp, &foo.sin_addr);
//替代:
inet_aton(cp,&foo.sin_addr);
char str[INET_ADDRSTRLEN];
ptr = inet_ntop(AFINET,&foo.sin_addr,str,sizeof(str));
//替代:
ptr = inet_ntoa(foo.sin_addr);

4. sock_ntop和相关函数

// IPV4 时:
struct sockaddr_in addr;
inet_ntop(AF_INET,&addr.sin_addr,str,szieof(str));
// IPv6 时:
struct sockaddr_in6 addr;
inet_ntop(AF_INET6,&addr.sin6_addr,str,szieof(str));

5. readn 、 writen、 readline函数

#include "unp.h"
ssize_t readn(int filedes, void *buff, size_t nbytes);
ssize_t written(int filedes, const void *buff, size_t nbytes );
ssize_t readline(int filedes, void *buff, size_t maxlen);
 返回:读或写的字节数,若出错则为-1

二、基本TCP套接字编程

1. socket 函数

#include<sys/socket.h>
int socket(int family, int type, int protocol);
 返回:成功返回描述符,失败-1

2. connect函数

#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *servaddr,socklen_t addrlen);
 返回:成功 0,失败 -1

3. bind 函数

#include <sys/socket.h>
int bind(int sockfd,const struct sockaddr *myaddr, socklen_t addrlen);
 返回:成功0 失败 -1

4. listen 函数

#include <sys/socket.h>
int listen(int sockfd, int backlog);
 返回:成功 0 失败 -1

5. accept 函数

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);
 返回:成功 返回描述符, 出错 -1

6. fork 函数

#include <unistd.h>
pid_t fork(void);
 返回:子进程中为 0,父进程为子进程 ID,出错 -1

7. exec 函数

#include <unistd.h>
int execl(const char *pathname, const char *arg0, .../* (char *) 0 */);
int execv(const char *pathname, char *const *argv[]);
int execle(const char *pathname, const char *arg0, .../* (cahr *) 0, char *const envp[] */);
int execve(const char *pathname, char *const *argv[], char *const envp[]);
int execlp(const char *fliename, const char *arg0, .../* (char *) 0 */);
int execvp(const char *filename, char *const argv[]);
 返回:成功不返回,出错 -1

8. close 函数

#include <unistd.h>
int close(int sockfd);
 返回: 成功 0,失败 -1

9. getsockname 函数和 getpeername 函数

#include <sys/socket.h>
int getsockname(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen);
int getpeername(int sockfd, struct sockaddr *peeraddr, socklen_t *addrlen);
 返回:成功 0,失败 -1

三、TCP 客户端/服务器程序范式

1. 其他函数准备

1. TCP 回射服务器程序: str_echo 函数

#include "unp.h"
void str_echo(int sockfd)
{
 ssize_t n;
 char buf[MAXLINE];
 
again:
 while((n = read(sockfd, buf, MAXLINE)) > 0)
 Writen(sockfd, buf, n);
 
 if(n < 0 && errno == EINTR) // 被中断后继续执行
 goto again;
 else if(n < 0)
 err_sys("str_echo: read error");
}

2. TCP 回射客户端程序: str_cli 函数

#include "unp.h"
void str_cli(FILE *fp, int sockfd)
{
 char sendline[MAXLINE], recvline[MAXLINE];
 
 while(Fgets(sendline, NAXLINE, fp) != NULL)
 {
 Writen(sockfd, sendline, strlen(sendline));
 
 if(Readline(sockfd, recvline, MALINE) == 0)
 err_quit("str_cli: server terminated prematurely");
 Fputs(recvline, stdout);
 
 }
 
}

2. TCP 客户端/服务器设计范式

1. 迭代式

TCP 客户端

#include "unp.h"
int main(int argc, char **argv)
{
 int sockfd;
 struct sockaddr_in servaddr;
 
 if(argc != 2)
 err_quit("usage: tcpcli <IPaddress>");
 
 sockfd = Socket(AF_INET, SOCK_STREAM, 0);
 
 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_port = htons(SERV_PORT);
 Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
 
 Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
 
 str_cli(stdin, sockfd); /*do it all*/
 
 exit(0); 
}

TCP 服务器端

#include "unp.h"
int main(int argc, char **argv)
{
 int listenfd, connfd;
 pid_t childpid;
 socklen_t clilen;
 struct sockaddr_in cliaddr, servaddr;
 
 void sig_chld(int);
 
 listenfd = Socket(AF_INET, SOCK_STREAN, 0);
 
 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 servaddr.sin_port = htons(SERV_PORT);
 
 Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));
 
 Listen(listenfd, LISTENQ);
 
 Signal(SIGCHLD, sig_chld); /*必须调用 waitpid() 回收僵尸进程*/
 
 for( ; ; )
 {
 chilen = sizeof(chiaddr);
 if((connfd = accept(listenfd, (SA *) &cliaddr, &clilen)) < 0)
 {
 if(errno == EINTR) // 被中断重新调用
 continue;
 else
 err_sys("accept error");
 }
 if((childpid = Fork()) == 0)/* 子进程*/
 {
 Close(lisenfd); /*关闭监听套接字*/ // 关闭后面没用的套接字
 str_echo(connfd);
 exit(0);
 }
 Close(connfd); /*必须关闭 不然一直占用描述符*/
 }
 
}
/**********************************************************************************/
// 回收子进程 避免产生僵尸进程
void sig_chld(int signo)
{
 pid_t pid;
 int stat;
 
 while( (pid = waitpid(-1, &stat, WNOHANG)) > 0) // WNOHANG 不阻塞
 printf("child %d terminated\n", pid);
 
 return;
}

问题分析

僵尸进程与处理

accept 中必须处理中断

总结

服务器异常分析

服务器进程终止

SIGPIPE 信号

服务器主机崩溃

服务器主机崩溃后重启

服务器主机关机

总结

2. select I/O复用式

基本 I/O 模型

阻塞式 I/O 模型

非阻塞式 I/O 模型

I/O 复用模型

信号驱动式 I/O 模型

异步 I/O 模型

各种 I/O 模型比较

select 函数

#include <sys/select.h>
#include <sys/time.h>
int select(int maxfdp1, fd_set *readset, fd _set *writeset, fd_set *exceptset, const struct timeval *timeout);
 返回:有指定的描述符就绪则为其数目,超时为 0 ,出错为 -1

shutdown 函数

#include <sys/socket.h>
int shutdown(int sockfd, int howto);
 返回:成功 0,失败 -1

str_cli 函数

#include	"unp.h"
void
str_cli(FILE *fp, int sockfd)
{
	int			maxfdp1, stdineof;
	fd_set		rset;
	char		buf[MAXLINE];
	int		n;
	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);
		if (FD_ISSET(sockfd, &rset)) {	/* socket is readable */
			if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
				if (stdineof == 1)
					return;		/* normal termination */
				else
					err_quit("str_cli: server terminated prematurely");
			}
			Write(fileno(stdout), buf, n);
		}
		if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
			if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) {
				stdineof = 1;
				Shutdown(sockfd, SHUT_WR);	/* send FIN */
				FD_CLR(fileno(fp), &rset);
				continue;
			}
			Writen(sockfd, buf, n);
		}
	}
}

TCP 服务器程序(select 版)

/* include fig01 */
#include	"unp.h"
int
main(int argc, char **argv)
{
	int					i, maxi, maxfd, listenfd, connfd, sockfd;
	int					nready, client[FD_SETSIZE];
	ssize_t				n;
	fd_set				rset, allset;
	char				buf[MAXLINE];
	socklen_t			clilen;
	struct sockaddr_in	cliaddr, servaddr;
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
	Listen(listenfd, LISTENQ);
	maxfd = listenfd;			/* initialize */
	maxi = -1;					/* index into client[] array */
	for (i = 0; i < FD_SETSIZE; i++)
		client[i] = -1;			/* -1 indicates available entry */
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
/* end fig01 */
/* include fig02 */
	for ( ; ; ) {
		rset = allset;		/* structure assignment */
		nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
		if (FD_ISSET(listenfd, &rset)) {	/* new client connection */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef	NOTDEF
			printf("new client: %s, port %d\n",
					Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
					ntohs(cliaddr.sin_port));
#endif
			for (i = 0; i < FD_SETSIZE; i++)
				if (client[i] < 0) {
					client[i] = connfd;	/* save descriptor */
					break;
				}
			if (i == FD_SETSIZE)
				err_quit("too many clients");
			FD_SET(connfd, &allset);	/* add new descriptor to set */
			if (connfd > maxfd)
				maxfd = connfd;			/* for select */
			if (i > maxi)
				maxi = i;				/* max index in client[] array */
			if (--nready <= 0)
				continue;				/* no more readable descriptors */
		}
		for (i = 0; i <= maxi; i++) {	/* check all clients for data */
			if ( (sockfd = client[i]) < 0)
				continue;
			if (FD_ISSET(sockfd, &rset)) {
				if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
						/*4connection closed by client */
					Close(sockfd);
					FD_CLR(sockfd, &allset);
					client[i] = -1;
				} else
					Writen(sockfd, buf, n);
				if (--nready <= 0)
					break;				/* no more readable descriptors */
			}
		}
	}
}

poll 函数

#include <poll.h>
int poll(struct pollfd *fdarray, unsigned long nfds, int timeout);
 返回:若有就绪描述符则为其数目,若超时则为 0, 若出错则为-1

TCP 服务器程序(poll 版)

/* include fig01 */
#include	"unp.h"
#include	<limits.h>		/* for OPEN_MAX */
int
main(int argc, char **argv)
{
	int					i, maxi, listenfd, connfd, sockfd;
	int					nready;
	ssize_t				n;
	char				buf[MAXLINE];
	socklen_t			clilen;
	struct pollfd		client[OPEN_MAX];
	struct sockaddr_in	cliaddr, servaddr;
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);
	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
	Listen(listenfd, LISTENQ);
	client[0].fd = listenfd;
	client[0].events = POLLRDNORM;
	for (i = 1; i < OPEN_MAX; i++)
		client[i].fd = -1;		/* -1 indicates available entry */
	maxi = 0;					/* max index into client[] array */
	for ( ; ; ) {
		nready = Poll(client, maxi+1, INFTIM);
		if (client[0].revents & POLLRDNORM) {	/* new client connection */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
			
			for (i = 1; i < OPEN_MAX; i++)
				if (client[i].fd < 0) {
					client[i].fd = connfd;	/* save descriptor */
					break;
				}
			if (i == OPEN_MAX)
				err_quit("too many clients");
			client[i].events = POLLRDNORM;
			if (i > maxi)
				maxi = i;				/* max index in client[] array */
			if (--nready <= 0)
				continue;				/* no more readable descriptors */
		}
		for (i = 1; i <= maxi; i++) {	/* check all clients for data */
			if ( (sockfd = client[i].fd) < 0)
				continue;
			if (client[i].revents & (POLLRDNORM | POLLERR)) {
				if ( (n = read(sockfd, buf, MAXLINE)) < 0) {
					if (errno == ECONNRESET) {
							/*4connection reset by client */
						Close(sockfd);
						client[i].fd = -1;
					} else
						err_sys("read error");
				} else if (n == 0) {
						/*4connection closed by client */
					Close(sockfd);
					client[i].fd = -1;
				} else
					Writen(sockfd, buf, n);
				if (--nready <= 0)
					break;				/* no more readable descriptors */
			}
		}
	}
}

3. 非阻塞式 I/O

非阻塞读和写:str_cli 函数

描述

源码

说明

问题

4. 使用 fork 版的 str_cli 函数

描述

源码

#include	"unp.h"
void
str_cli(FILE *fp, int sockfd)
{
	pid_t	pid;
	char	sendline[MAXLINE], recvline[MAXLINE];
	if ( (pid = Fork()) == 0) {		/* child: server -> stdout */
		while (Readline(sockfd, recvline, MAXLINE) > 0)
			Fputs(recvline, stdout);
		kill(getppid(), SIGTERM);	/* in case parent still running */
		exit(0);
	}
		/* parent: stdin -> server */
	while (Fgets(sendline, MAXLINE, fp) != NULL)
		Writen(sockfd, sendline, strlen(sendline));
	Shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */
	pause();
	return;
}

说明

5. 线程版

pthread_create 函数

#include<pthread.h>
int pthread_create(pthread_t *tid,const pthread_attr_t *attr, void *(*func)(void *),void *arg);
 返回:成功 0,失败 error 值

基本线程函数

pthread_join 函数

#include <pthread.h>
int pthread_join(pthread_t *pid, void **status);
 返回:成功 0, 出错正的 error 值

pthread_self 函数

#include <pthread.h>
pthread_t pthread_self(void);
 返回:调用线程的 ID

pthread_detach 函数

#incldue <pthread.h>
int pthread_detach(pthread_t tid);
 返回:成功 0 ,失败 正的 error 值

pthread_exit 函数

#include <pthread.h>
void pthread_exit(void *status);

使用线程的 str_cli 程序

#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;
	sockfd = sockfd_arg;	/* copy arguments to externals */
	fp = fp_arg;
	Pthread_create(&tid, NULL, copyto, NULL);
	while (Readline(sockfd, recvline, MAXLINE) > 0)
		Fputs(recvline, stdout);
}
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 */
}

使用线程的 TCP 回射服务器程序

#include	"unpthread.h"
static void	*doit(void *);		/* each thread executes this function */
int
main(int argc, char **argv)
{
	int				listenfd, connfd;
	pthread_t		tid;
	socklen_t		addrlen, len;
	struct sockaddr	*cliaddr;
	if (argc == 2)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 3)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: tcpserv01 [ <host> ] <service or port>");
	cliaddr = Malloc(addrlen);
	for ( ; ; ) {
		len = addrlen;
		connfd = Accept(listenfd, cliaddr, &len);
		Pthread_create(&tid, NULL, &doit, (void *) connfd);
	}
}
static void *
doit(void *arg)
{
	Pthread_detach(pthread_self());
	str_echo((int) arg);	/* same function as before */
	Close((int) arg);		/* done with connected socket */
	return(NULL);
}

#include	"unpthread.h"
static void	*doit(void *);		/* each thread executes this function */
int
main(int argc, char **argv)
{
	int				listenfd, *iptr;
	thread_t		tid;
	socklen_t		addrlen, len;
	struct sockaddr	*cliaddr;
	if (argc == 2)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 3)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: tcpserv01 [ <host> ] <service or port>");
	cliaddr = Malloc(addrlen);
	for ( ; ; ) {
		len = addrlen;
		iptr = Malloc(sizeof(int)); //
		*iptr = Accept(listenfd, cliaddr, &len); // 每次分配一个单独的空间 
		Pthread_create(&tid, NULL, &doit, iptr);
	}
}
static void *
doit(void *arg)
{
	int		connfd;
	connfd = *((int *) arg);
	free(arg);
	Pthread_detach(pthread_self());
	str_echo(connfd);		/* same function as before */
	Close(connfd);			/* done with connected socket */
	return(NULL);
}

线程同步

互斥锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mptr);
int pthread_mutex_unlock(pthread_mutex_t *mptr);
 返回:成功 0,失败 值为正的 error

#include	"unpthread.h"
#define	NLOOP 5000
int				counter;		/* incremented by threads */
pthread_mutex_t	counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void	*doit(void *);
int
main(int argc, char **argv)
{
	pthread_t	tidA, tidB;
	Pthread_create(&tidA, NULL, &doit, NULL);
	Pthread_create(&tidB, NULL, &doit, NULL);
		/* 4wait for both threads to terminate */
	Pthread_join(tidA, NULL);
	Pthread_join(tidB, NULL);
	exit(0);
}
void *
doit(void *vptr)
{
	int		i, val;
	/*
	 * Each thread fetches, prints, and increments the counter NLOOP times.
	 * The value of the counter should increase monotonically.
	 */
	for (i = 0; i < NLOOP; i++) {
		Pthread_mutex_lock(&counter_mutex); // 加锁
		val = counter;
		printf("%d: %d\n", pthread_self(), val + 1);
		counter = val + 1;
		Pthread_mutex_unlock(&counter_mutex); // 解锁
	}
	return(NULL);
}

条件变量

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *cptr, pthread_mutex_t *mptr);
int pthread_cond_signal(pthred_cond_t *cptr);
 返回: 成功 0;失败 正的 error

int ndone;
pthread_mutex_t ndone_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cont_t ndone_cond = PTHREAD_COND_INITIALIZER;
通过在持有该互斥锁期间递增该值,并发送信号到该条件变量,一个线程通知主循环自身即将终止
Pthread_mutex_lock(&ndone_mutex);
ndone++;
Pthread_cond_signal(&ndone_cond);
Pthread_mutex_unlock(&ndone_mutex);
----------------------------------------------------------------------------------
主循环阻塞在 pthread_cond_wait 调用中,等待某个即将终止的线程发送信号到与 ndone 相关联的条件变量
while(nlefttoread > 0)
{
 while(nconn < maxnconn && nefttoconn > 0)
 {
 /* 找一个文件读 */
 }
 
 /* 等待条件变量 */
 
 Pthread_mutex_lock(&ndone_mutex); // 持有锁
 while(ndone == 0)
 Pthread_cond_wait(&ndone_cond,&ndone_mutex);
 // 条件等到了
 
 // do eles
 
 Pthread_mutex_unlock(&ndone_mutex);
}

#include <pthread.h>
// 同时唤醒相同条件变量上的多个线程 
int pthread_cond_broadcast(pthread_cond_t *cptr);
// 设置等待时限
int pthread_cond_timedwait(pthread_cond_t *cptr,pthread_mutex_t *mptr,const struct timespec *abstime);
 返回:成功 1,失败 正值的 error

7. 进程池版服务器(accept 无上锁保护)

/* include serv02 */
#include	"unp.h"
static int		nchildren;
static pid_t	*pids;
int
main(int argc, char **argv)
{
	int			listenfd, i;
	socklen_t	addrlen;
	void		sig_int(int);
	pid_t		child_make(int, int, int);
	if (argc == 3)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 4)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: serv02 [ <host> ] <port#> <#children>");
	nchildren = atoi(argv[argc-1]);
	pids = Calloc(nchildren, sizeof(pid_t));
	for (i = 0; i < nchildren; i++)
		pids[i] = child_make(i, listenfd, addrlen);	/* parent returns */
	Signal(SIGINT, sig_int);
	for ( ; ; )
		pause();	/* everything done by children */
}
/* end serv02 */
/* include sigint */
void
sig_int(int signo)
{
	int		i;
	void	pr_cpu_time(void);
		/* 4terminate all children */
	for (i = 0; i < nchildren; i++)
		kill(pids[i], SIGTERM);
	while (wait(NULL) > 0)		/* wait for all children */
		;
	if (errno != ECHILD)
		err_sys("wait error");
	pr_cpu_time();
	exit(0);
}
/* end sigint */
/* include child_make */
#include	"unp.h"
pid_t
child_make(int i, int listenfd, int addrlen)
{
	pid_t	pid;
	void	child_main(int, int, int);
	if ( (pid = Fork()) > 0)
		return(pid);		/* parent */
	child_main(i, listenfd, addrlen);	/* never returns */
}
/* end child_make */
/* include child_main */
void
child_main(int i, int listenfd, int addrlen)
{
	int				connfd;
	void			web_child(int);
	socklen_t		clilen;
	struct sockaddr	*cliaddr;
	cliaddr = Malloc(addrlen);
	printf("child %ld starting\n", (long) getpid());
	for ( ; ; ) {
		clilen = addrlen;
		connfd = Accept(listenfd, cliaddr, &clilen);
		web_child(connfd);		/* process the request */
		Close(connfd);
	}
}
/* end child_main */

8. 进程池版服务器(accept 使用文件上锁保护)

/* include my_lock_init */
#include	"unp.h"
static struct flock	lock_it, unlock_it;
static int			lock_fd = -1;
					/* fcntl() will fail if my_lock_init() not called */
void
my_lock_init(char *pathname)
{
 char	lock_file[1024];
		/* 4must copy caller's string, in case it's a constant */
 strncpy(lock_file, pathname, sizeof(lock_file));
 lock_fd = Mkstemp(lock_file);
 Unlink(lock_file);			/* but lock_fd remains open */
	lock_it.l_type = F_WRLCK;
	lock_it.l_whence = SEEK_SET;
	lock_it.l_start = 0;
	lock_it.l_len = 0;
	unlock_it.l_type = F_UNLCK;
	unlock_it.l_whence = SEEK_SET;
	unlock_it.l_start = 0;
	unlock_it.l_len = 0;
}
/* end my_lock_init */
/* include my_lock_wait */
void
my_lock_wait()
{
 int		rc;
 
 while ( (rc = fcntl(lock_fd, F_SETLKW, &lock_it)) < 0) {
		if (errno == EINTR)
			continue;
 	else
			err_sys("fcntl error for my_lock_wait");
	}
}
void
my_lock_release()
{
 if (fcntl(lock_fd, F_SETLKW, &unlock_it) < 0)
		err_sys("fcntl error for my_lock_release");
}
/* end my_lock_wait */

9. 进程池版服务器(accept 使用线程上锁保护)

/* include my_lock_init */
#include	"unpthread.h"
#include	<sys/mman.h>
static pthread_mutex_t	*mptr;	/* actual mutex will be in shared memory */
void
my_lock_init(char *pathname)
{
	int		fd;
	pthread_mutexattr_t	mattr;
	fd = Open("/dev/zero", O_RDWR, 0);
	mptr = Mmap(0, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE,
				MAP_SHARED, fd, 0);
	Close(fd);
	Pthread_mutexattr_init(&mattr);
	Pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
	Pthread_mutex_init(mptr, &mattr);
}
/* end my_lock_init */
/* include my_lock_wait */
void
my_lock_wait()
{
	Pthread_mutex_lock(mptr);
}
void
my_lock_release()
{
	Pthread_mutex_unlock(mptr);
}
/* end my_lock_wait */

10. 进程池版服务器(传递描述符)

typedef struct {
 pid_t		child_pid;		/* process ID */
 int		child_pipefd;	/* 管道 parent's stream pipe to/from child */
 int		child_status;	/* 状态 0 = ready */
 long		child_count;	/* 已处理客户计数 # connections handled */
} Child;
Child	*cptr;		/* array of Child structures; calloc'ed */

/* include serv05a */
#include	"unp.h"
#include	"child.h"
static int		nchildren;
int
main(int argc, char **argv)
{
	int			listenfd, i, navail, maxfd, nsel, connfd, rc;
	void		sig_int(int);
	pid_t		child_make(int, int, int);
	ssize_t		n;
	fd_set		rset, masterset;
	socklen_t	addrlen, clilen;
	struct sockaddr	*cliaddr;
	if (argc == 3)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 4)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: serv05 [ <host> ] <port#> <#children>");
	FD_ZERO(&masterset);
	FD_SET(listenfd, &masterset);
	maxfd = listenfd;
	cliaddr = Malloc(addrlen);
	nchildren = atoi(argv[argc-1]);
	navail = nchildren;
	cptr = Calloc(nchildren, sizeof(Child));
		/* 4prefork all the children */
	for (i = 0; i < nchildren; i++) {
		child_make(i, listenfd, addrlen);	/* parent returns */
		FD_SET(cptr[i].child_pipefd, &masterset);
		maxfd = max(maxfd, cptr[i].child_pipefd);
	}
	Signal(SIGINT, sig_int);
	for ( ; ; ) {
		rset = masterset;
		if (navail <= 0)
			FD_CLR(listenfd, &rset);	/* turn off if no available children */
		nsel = Select(maxfd + 1, &rset, NULL, NULL, NULL);
			/* 4check for new connections */
		if (FD_ISSET(listenfd, &rset)) {
			clilen = addrlen;
			connfd = Accept(listenfd, cliaddr, &clilen);
			for (i = 0; i < nchildren; i++)
				if (cptr[i].child_status == 0)
					break;				/* available */
			if (i == nchildren)
				err_quit("no available children");
			cptr[i].child_status = 1;	/* mark child as busy */
			cptr[i].child_count++;
			navail--;
			n = Write_fd(cptr[i].child_pipefd, "", 1, connfd);
			Close(connfd);
			if (--nsel == 0)
				continue;	/* all done with select() results */
		}
			/* 4find any newly-available children */
		for (i = 0; i < nchildren; i++) {
			if (FD_ISSET(cptr[i].child_pipefd, &rset)) {
				if ( (n = Read(cptr[i].child_pipefd, &rc, 1)) == 0)
					err_quit("child %d terminated unexpectedly", i);
				cptr[i].child_status = 0;
				navail++;
				if (--nsel == 0)
					break;	/* all done with select() results */
			}
		}
	}
}
/* end serv05a */
void
sig_int(int signo)
{
	int		i;
	void	pr_cpu_time(void);
		/* 4terminate all children */
	for (i = 0; i < nchildren; i++)
		kill(cptr[i].child_pid, SIGTERM);
	while (wait(NULL) > 0)		/* wait for all children */
		;
	if (errno != ECHILD)
		err_sys("wait error");
	pr_cpu_time();
	for (i = 0; i < nchildren; i++)
		printf("child %d, %ld connections\n", i, cptr[i].child_count);
	exit(0);
}
/* include child_make */
#include	"unp.h"
#include	"child.h"
pid_t
child_make(int i, int listenfd, int addrlen)
{
	int		sockfd[2];
	pid_t	pid;
	void	child_main(int, int, int);
	Socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd);
	if ( (pid = Fork()) > 0) {
		Close(sockfd[1]);
		cptr[i].child_pid = pid;
		cptr[i].child_pipefd = sockfd[0];
		cptr[i].child_status = 0;
		return(pid);		/* parent */
	}
	Dup2(sockfd[1], STDERR_FILENO);		/* child's stream pipe to parent */
	Close(sockfd[0]);
	Close(sockfd[1]);
	Close(listenfd);					/* child does not need this open */
	child_main(i, listenfd, addrlen);	/* never returns */
}
/* end child_make */
/* include child_main */
void
child_main(int i, int listenfd, int addrlen)
{
	char			c;
	int				connfd;
	ssize_t			n;
	void			web_child(int);
	printf("child %ld starting\n", (long) getpid());
	for ( ; ; ) {
		if ( (n = Read_fd(STDERR_FILENO, &c, 1, &connfd)) == 0)
			err_quit("read_fd returned 0");
		if (connfd < 0)
			err_quit("no descriptor from read_fd");
		web_child(connfd);				/* process request */
		Close(connfd);
		Write(STDERR_FILENO, "", 1);	/* tell parent we're ready again */
	}
}
/* end child_main */

11. 线程池版服务器(每个线程各自 accept)

typedef struct {
 pthread_t		thread_tid;		/* thread ID */
 long			thread_count;	/* # connections handled */
} Thread;
Thread	*tptr;		/* array of Thread structures; calloc'ed */
int				listenfd, nthreads;
socklen_t		addrlen;
pthread_mutex_t	mlock;

/* include serv07 */
#include	"unpthread.h"
#include	"pthread07.h"
pthread_mutex_t	mlock = PTHREAD_MUTEX_INITIALIZER;
int
main(int argc, char **argv)
{
	int		i;
	void	sig_int(int), thread_make(int);
	if (argc == 3)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 4)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: serv07 [ <host> ] <port#> <#threads>");
	nthreads = atoi(argv[argc-1]);
	tptr = Calloc(nthreads, sizeof(Thread));
	for (i = 0; i < nthreads; i++)
		thread_make(i);			/* only main thread returns */
	Signal(SIGINT, sig_int);
	for ( ; ; )
		pause();	/* everything done by threads */
}
/* end serv07 */
void
sig_int(int signo)
{
	int		i;
	void	pr_cpu_time(void);
	pr_cpu_time();
	for (i = 0; i < nthreads; i++)
		printf("thread %d, %ld connections\n", i, tptr[i].thread_count);
	exit(0);
}
#include	"unpthread.h"
#include	"pthread07.h"
void
thread_make(int i)
{
	void	*thread_main(void *);
	Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *) i);
	return;		/* main thread returns */
}
void *
thread_main(void *arg)
{
	int				connfd;
	void			web_child(int);
	socklen_t		clilen;
	struct sockaddr	*cliaddr;
	cliaddr = Malloc(addrlen);
	printf("thread %d starting\n", (int) arg);
	for ( ; ; ) {
		clilen = addrlen;
 	Pthread_mutex_lock(&mlock);
		connfd = Accept(listenfd, cliaddr, &clilen);
		Pthread_mutex_unlock(&mlock);
		tptr[(int) arg].thread_count++;
		web_child(connfd);		/* process request */
		Close(connfd);
	}
}

12. 线程池版服务器(主线程统一 accept)

typedef struct {
 pthread_t		thread_tid;		/* thread ID */
 long			thread_count;	/* # connections handled */
} Thread;
Thread	*tptr;		/* array of Thread structures; calloc'ed */
#define	MAXNCLI	32
int					clifd[MAXNCLI], iget, iput;
pthread_mutex_t		clifd_mutex;
pthread_cond_t		clifd_cond;

/* include serv08 */
#include	"unpthread.h"
#include	"pthread08.h"
static int			nthreads;
pthread_mutex_t		clifd_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t		clifd_cond = PTHREAD_COND_INITIALIZER;
int
main(int argc, char **argv)
{
	int			i, listenfd, connfd;
	void		sig_int(int), thread_make(int);
	socklen_t	addrlen, clilen;
	struct sockaddr	*cliaddr;
	if (argc == 3)
		listenfd = Tcp_listen(NULL, argv[1], &addrlen);
	else if (argc == 4)
		listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
	else
		err_quit("usage: serv08 [ <host> ] <port#> <#threads>");
	cliaddr = Malloc(addrlen);
	nthreads = atoi(argv[argc-1]);
	tptr = Calloc(nthreads, sizeof(Thread));
	iget = iput = 0;
		/* 4create all the threads */
	for (i = 0; i < nthreads; i++)
		thread_make(i);		/* only main thread returns */
	Signal(SIGINT, sig_int);
	for ( ; ; ) {
		clilen = addrlen;
		connfd = Accept(listenfd, cliaddr, &clilen);
		Pthread_mutex_lock(&clifd_mutex);
		clifd[iput] = connfd;
		if (++iput == MAXNCLI)
			iput = 0;
		if (iput == iget)
			err_quit("iput = iget = %d", iput);
		Pthread_cond_signal(&clifd_cond);
		Pthread_mutex_unlock(&clifd_mutex);
	}
}
/* end serv08 */
void
sig_int(int signo)
{
	int		i;
	void	pr_cpu_time(void);
	pr_cpu_time();
	for (i = 0; i < nthreads; i++)
		printf("thread %d, %ld connections\n", i, tptr[i].thread_count);
	exit(0);
}
#include	"unpthread.h"
#include	"pthread08.h"
void
thread_make(int i)
{
	void	*thread_main(void *);
	Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *) i);
	return;		/* main thread returns */
}
void *
thread_main(void *arg)
{
	int		connfd;
	void	web_child(int);
	printf("thread %d starting\n", (int) arg);
	for ( ; ; ) {
 	Pthread_mutex_lock(&clifd_mutex);
		while (iget == iput)
			Pthread_cond_wait(&clifd_cond, &clifd_mutex);
		connfd = clifd[iget];	/* connected socket to service */
		if (++iget == MAXNCLI)
			iget = 0;
		Pthread_mutex_unlock(&clifd_mutex);
		tptr[(int) arg].thread_count++;
		web_child(connfd);		/* process request */
		Close(connfd);
	}
}