当前位置: > 华清远见教育集团 > 嵌入式学习 > 讲师博文 > 网络编程中的并发控制
网络编程中的并发控制
时间:2017-11-27作者:华清远见

在Linux网络编程中,一般建立在两端之间,服务器端和客户端。客户端是面向用户的应用,而服务器端要处理客户端所提出的请求。通常一个服务器要面向多个客户端,保证对每个客户端都能高效的处理,这时候需要并发操作。实现并发控制的方法有两个,一个是并发服务器,另一个是多路复用I/O,现在就给大家介绍一下这两种方法。

方法一:并发服务器

这个方法可以通过进程(线程)来实现,主要根据子进程(子线程)之间并行运行的特点。将对客户端请求的处理工作,交于子进程(子线程)来处理,达到一个服务器同时处理多个客户端的效果。通过2个例子实现一个简单的服务器与客户端的一对多。

例1:进程实现并发服务器(TCP通信)

首先,服务器端代码如下:

#include<stdio.h>

#include<sys/types.h>

#include<arpa/inet.h>

#include<string.h>

#include<sys/socket.h>

#include<unistd.h>

#include<stdlib.h>

int main()

{

int sockfd, newfd, r;

struct sockaddr_in myaddr;

struct sockaddr fromaddr;

socklen_t len = 16;

char buf[100] = {0};

pid_t pid;             

sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建TCP通信的套接字--流式套接字  

myaddr.sin_family = AF_INET;         // 地址信息填写  

myaddr.sin_port = htons(56666); // 要绑定的端口号

myaddr.sin_addr.s_addr = inet_addr("127.0.0.1");// 要绑定的地址 这里以 127.0.0.1为例

r = bind(sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr));   // 绑定地址信息 

if( listen(sockfd, 10) < 0){   // 设置监听 同一时刻能客户端的连接请求的大数

perror("listen ");return -1;

}

while(1) {       // 循环 

newfd = accept(sockfd, &fromaddr, &len);   // 阻塞接收 客户端的连接请求

pid = fork(); // 创建新进程

if(pid == 0){ // 子进程   处理以连接成功的客户端

while(1){

r = recv(newfd, buf, 100, 0);     //处理客户端  接收信息

if(r <= 0){ printf("客户端已退出:%d \n",newfd);break; }

printf("%d : %s\n", newfd, buf);

bzero(buf, strlen(buf));

}

close(newfd);      // 关闭 连接

exit(0);   // 处理完  子进程退出

}else if(pid < 0){   exit(0);  }

}

close(sockfd);

}

客户端代码如下:

int main()

{

int sockfd,r;

char buf[100] = {0};

struct sockaddr_in toaddr;

sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建TCP通信的套接字--流式套接字

printf("sockfd = %d\n", sockfd);

toaddr.sin_family = AF_INET;         // 地址信息填写  

toaddr.sin_port = htons(56666); // 对方的端口号

toaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 对方的IP地址

    // 发送连接请求 与对方建立连接

r = connect(sockfd, (struct sockaddr *)&toaddr, sizeof(toaddr));

    if(r == -1){ perror("connect "); return -1;  }

printf("connect OK\n");          // 连接成功

while(1){ // 循环 向服务器端发送信息

scanf("%s", buf);

send(sockfd, buf, strlen(buf), 0);

}

close(sockfd);

}

然后,编译服务器端 和 客户端,终端执行如图1命令:

图1 编译文件

用一个终端执行服务器,多个终端执行客户端,结果如图2:

左边第一个是服务器端,先开启;右边2个是客户端,同时访问服务器;服务器能同时处理这些客户端。

图2 执行结果

例2:线程实现并发服务器(TCP通信)

首先,服务器端代码如下:

……

#include<pthread.h>

void * fun(void *p)     // 线程处理函数 

{

int fd = *((int *)p);  // 获取传参  得到 套接字描述符 

char buf[100] = {0};

int r;

printf("pthread fd = %d start\n", fd);

while(1){ //循环 接受信息 

r = recv(fd, buf, 100, 0);

if(r <= 0){ printf("客户端已退出 : %d\n",fd); break;  }

printf("%d : %s\n", fd, buf);

bzero(buf,strlen(buf));

}

close(fd);   // 关闭套接字 线程结束  

}

int main()

{

int sockfd, newfd, r;

struct sockaddr_in myaddr;

struct sockaddr fromaddr;

socklen_t len = 16;

char buf[100] = {0};

pthread_t tid;

sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建TCP通信的套接字--流式套接字

myaddr.sin_family = AF_INET; // 地址信息填写  

myaddr.sin_port = htons(56666); // 端口号

myaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // IP地址

r = bind(sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr)); // 绑定

if( listen(sockfd, 10) < 0) {  perror("listen "); return -1;  } //监听

while(1){ // 进程 循环接受客户端的请求

newfd = accept(sockfd, &fromaddr, &len);  // 阻塞 接受  并建立连接

printf("newfd = %d\n", newfd);

pthread_create(&tid, NULL, fun, &newfd); //创建线程  将连接好的套接字传给线程

}

    close(sockfd);

}

客户端代码,同例1中客户端代码。

编译服务器和客户端,终端执行命令,如图3:注意线程编译时加载库。

图3 gcc编译

用一个终端执行服务器,多个终端执行客户端,结果如图4。左边第一个是服务器端,先开启;右边2个是客户端,同时访问服务器;服务器为客户端创建线程,同时处理这些客户端。

图4 执行结果

方法二:多路复用I/O

基本思想:有一个存储文件描述符的表,有固定的函数(select)可以检测表中的文件描述符状态,当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。

函数返回时告诉进程那个描述符已就绪,可以进行I/O操作。

解决问题:多进程(多线程)情况下程序的复杂性较高,阻塞模式/非阻塞模式下效率低。IO多路复用是更好的方法,逻辑简单、效率高。

IO多路复用涉及函数 :第一:select函数  功能:检测表中文件描述符的状态

函数原型 : #include<sys/select.h>  #include<sys/types.h> #include<unistd.h>

int select(int n, fd_set * read_fds, fd_set *write_fds, fd_set *except_dst, struct timeval *timeout);

n : 文件描述符大值+1

read_fds : 所有读文件描述符的集合

write_fds : 写 文件描述符集合

except_fds : 其他的 文件描述符集合

timeout :  阻塞等待的时间   毫秒 

struct timeval t = {5, 600};    &t    5.6秒

NULL/0              无限等待

struct timeval t = {0, 0};   &t    0秒  不等待

返回值 :  就绪描述符的数目

               超时返回 0

      失败返回 -1 

第二:文件描述符操作函数(宏定义) 

void FD_SET(int fd, fd_set *fds);   将文件描述符 添加到 表中

void FD_CLR(int fd, fd_set *fds);   删除 一个文件描述符 

void FD_ZERO(fd_set *fds);       清零

int FD_ISSET(int fd, fd_set *fds);      判断 fd  是否已经准备I/O

服务器端可以采用多路IO复用实现一对多处理,代码如下:

……

#include<sys/select.h>

int main()

{

int sockfd, newfd, r, i, maxfd;

struct sockaddr_in myaddr;

struct sockaddr fromaddr;

socklen_t len = 16;

char buf[100] = {0};

fd_set fds;

sockfd = socket(AF_INET, SOCK_STREAM, 0);// 创建TCP通信的套接字--流式套接字

myaddr.sin_family = AF_INET; // 地址信息填写  

myaddr.sin_port = htons(56667); // 端口号

myaddr.sin_addr.s_addr = inet_addr("127.0.0.1");// IP地址

r = bind(sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr)); // 绑定

if( listen(sockfd, 10) < 0){  //监听

  perror("listen "); return -1;  }

FD_ZERO(&fds);      // 清空表

FD_SET(sockfd, &fds);  // 添加 套接字描述符 到表中

maxfd = sockfd;   // 记录 描述符 的 大值

while(1){

   // 阻塞 等待是否 有访问到来

r = select(maxfd+1, &fds, NULL, NULL, NULL);  

if(r <=0){ return -1;  }

for(i = 0; i <= maxfd;i++){

if(FD_ISSET(i, &fds)) {  //找出 I/O操作的套接字描述符

if(i == sockfd){     //  客户端 发送 连接请求

newfd = accept(i, &fromaddr, &len);  // 接受 并建立连接

printf("newfd = %d  start\n", newfd);

FD_SET(newfd, &fds); // 将新套接字描述符 添加到表中

maxfd = maxfd > newfd  ? maxfd : newfd;  // 更新 大值

else{       // 客户端 接收/发送 信息 

r = recv(i, buf, 100, 0);

if(r <= 0){

   close(i);

FD_CLR(i, &fds); // 从表中删除该套接字

}else {

send(i, buf, strlen(buf), 0);

printf("%d : %s\n", i, buf);

bzero(buf, strlen(buf));

}

}}}}}

客户端代码如下:

int main()

{

int sockfd,r;

char buf[100] = {0};

struct sockaddr_in toaddr;

sockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建TCP通信的套接字--流式套接字

printf("sockfd = %d\n", sockfd);

toaddr.sin_family = AF_INET;         // 地址信息填写  

toaddr.sin_port = htons(56667); // 对方的端口号

toaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); // 对方的IP地址

    // 发送连接请求 与对方建立连接

r = connect(sockfd, (struct sockaddr *)&toaddr, sizeof(toaddr));

if(r == -1){ perror("connect "); return -1; }

printf("connect OK\n");          // 连接成功

    scanf("%s", buf);

send(sockfd, buf, strlen(buf), 0); //向服务器端发送信息

bzero(buf, strlen(buf));

recv(sockfd, buf, 100, 0);    //收取对方的回发信息

printf("recv : %s\n", buf);

close(sockfd);

}

然后,gcc编译服务器端和客户端,分别生成可执行文件,在不同终端执行(左边第一个为服务器端,之后的是客户端),执行后结果如图5所示:

图5 执行结果图

在多路复用I/O中例子中,服务器端用的是for循环依次遍历描述符表,所以造成后面客户端的等待问题。

以上就是在网络编程中常用的并发操作,希望可以为你提供一定的帮助。


发表评论
前台专线:010-82525158 企业培训洽谈专线:010-82525379 院校合作洽谈专线:010-82525379 Copyright © 2004-2018 北京华清远见科技发展有限公司 版权所有 ,京ICP备16055225号,京公海网安备11010802025203号