Linux C语言 网络编程（二） server模型
前面介绍了关于连接linux服务端方式，可是服务端的资源是有限的，所以我们通常须要又一次思考，设计一套server模型来处理相应的client的请求。
第一种：并发server。通过主进程统一处理client的连接。当client连接过后。暂时fork（）进程，由子进程处理client请求，将连接请求和业务进行了分离。
server.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
static void handle_request(int s_c)
{
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); /*发送数据*/
}
/*关闭client*/
close(s_c);
}
static int handle_connect(int s_s)
{
int s_c; /*client套接字文件描写叙述符*/
struct sockaddr_in from; /*client地址*/
socklen_t len = sizeof(from);
/*主处理过程*/
while(1)
{
/*接收client连接*/
s_c = accept(s_s, (struct sockaddr*)&from, &len);
if(s_c > 0) /*client成功连接*/
{
/*创建进程进行数据处理*/
if(fork() > 0){ /*父进程*/
close(s_c); /*关闭父进程的client连接套接字*/
}else{
handle_request(s_c); /*处理连接请求*/
return(0);
}
}
}
}
int main(int argc, char *argv[])
{
int s_s; /*server套接字文件描写叙述符*/
struct sockaddr_in local; /*本地地址*/
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址*/
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); /*serverport*/
/*将套接字文件描写叙述符绑定到本地地址和port*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
listen(s_s, BACKLOG); /*侦听*/
/*处理client连接*/
handle_connect(s_s);
close(s_s);
return 0;
}
代码比較具体，easy理解。
以下介绍client代码，后面的client代码都是一样的。
client.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
int main(int argc, char *argv[])
{
int s; /*server套接字文件描写叙述符*/
struct sockaddr_in server; /*本地地址*/
char buff[BUFFLEN]; /*收发数据缓冲区*/
int n = 0; /*接收字符串长度*/
/*建立TCP套接字*/
s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址*/
memset(&server, 0, sizeof(server)); /*清零*/
server.sin_family = AF_INET; /*AF_INET协议族*/
server.sin_addr.s_addr = htonl(INADDR_ANY);/*随意本地地址*/
server.sin_port = htons(SERVER_PORT); /*serverport*/
/*连接server*/
connect(s, (struct sockaddr*)&server,sizeof(server));
memset(buff, 0, BUFFLEN); /*清零*/
strcpy(buff, "TIME"); /*复制发送字符串*/
/*发送数据*/
send(s, buff, strlen(buff), 0);
memset(buff, 0, BUFFLEN); /*清零*/
/*接收数据*/
n = recv(s, buff, BUFFLEN, 0);
/*打印消息*/
if(n >0){
printf("TIME:%s",buff);
}
close(s);
return 0;
}另外一种模型：通过线程来处理，线程比进程占用资源少，效率高，数据共享。通过pthread_create()建立一个连接请求处理。线程处理函数为handle_request().
server.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
static void handle_request(void *argv)
{
int s_c = *((int*)argv);
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); /*发送数据*/
}
/*关闭client*/
close(s_c);
}
static void handle_connect(int s_s)
{
int s_c; /*client套接字文件描写叙述符*/
struct sockaddr_in from; /*client地址*/
socklen_t len = sizeof(from);
pthread_t thread_do;
/*主处理过程*/
while(1)
{
/*接收client连接*/
s_c = accept(s_s, (struct sockaddr*)&from, &len);
if(s_c > 0) /*client成功连接*/
{
/*创建线程处理连接*/
pthread_create(&thread_do,
NULL,
(void*)handle_request,
&s_c);
}
}
}
int main(int argc, char *argv[])
{
int s_s; /*server套接字文件描写叙述符*/
struct sockaddr_in local; /*本地地址*/
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址和port*/
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); /*serverport*/
/*将套接字文件描写叙述符绑定到本地地址和port*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
listen(s_s, BACKLOG); /*侦听*/
/*处理client连接*/
handle_connect(s_s);
close(s_s);
return 0;
}第三种：服务端各线程独自accept(）。使用相互排斥锁，使用pthread_create()建立多个线程组成的线程池，主线程等待程序结束。各个线程独自接收clientaccept。以及后面数据处理。
server.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define CLIENTNUM 2
/*相互排斥量*/
pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER;
static void *handle_request(void *argv)
{
int s_s = *((int*)argv);
int s_c; /*client套接字文件描写叙述符*/
struct sockaddr_in from; /*client地址*/
socklen_t len = sizeof(from);
for(;;)
{
time_t now; /*时间*/
char buff[BUFFLEN]; /*收发数据缓冲区*/
int n = 0;
pthread_mutex_lock(&ALOCK); /*进入相互排斥区*/
s_c = accept(s_s, (struct sockaddr*)&from, &len);
/*接收client的请求*/
pthread_mutex_unlock(&ALOCK); /*离开相互排斥区*/
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); /*发送数据*/
}
/*关闭client*/
close(s_c);
}
return NULL;
}
static void handle_connect(int s)
{
int s_s = s;
pthread_t thread_do[CLIENTNUM]; /*线程ID*/
int i = 0;
for(i=0;i<CLIENTNUM;i++) /*建立线程池*/
{
/*创建线程*/
pthread_create(&thread_do[i], /*线程ID*/
NULL, /*属性*/
handle_request, /*线程回调函数*/
(void*)&s_s); /*线程參数*/
}
/*等待线程结束*/
for(i=0;i<CLIENTNUM;i++)
pthread_join(thread_do[i], NULL);
}
int main(int argc, char *argv[])
{
int s_s; /*server套接字文件描写叙述符*/
struct sockaddr_in local; /*本地地址*/
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址和port*/
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); /*serverport*/
/*将套接字文件描写叙述符绑定到本地地址和port*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
listen(s_s, BACKLOG); /*侦听*/
/*处理client连接*/
handle_connect(s_s);
close(s_s); /*关闭套接字*/
return 0;
}第四种：IO复用server。并发serverclient越多，对server造成的压力越大，所以还有第四种模型。IO复用函数用select来做。
server.c
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/select.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define CLIENTNUM 1024 /*最大支持client数量*/
/*可连接client的文件描写叙述符数组*/
int connect_host[CLIENTNUM];
int connect_number = 0;
static void *handle_request(void *argv)
{
time_t now; /*时间*/
char buff[BUFFLEN]; /*收发数据缓冲区*/
int n = 0;
int maxfd = -1; /*最大侦听文件描写叙述符*/
fd_set scanfd; /*侦听描写叙述符集合*/
struct timeval timeout; /*超时*/
timeout.tv_sec = 1; /* 堵塞1s后超时返回 */
timeout.tv_usec = 0;
int i = 0;
int err = -1;
for(;;)
{
/*最大文件描写叙述符值初始化为-1*/
maxfd = -1;
FD_ZERO(&scanfd); /*清零文件描写叙述符集合*/
for(i=0;i<CLIENTNUM;i++) /*将文件描写叙述符放入集合*/
{
if(connect_host[i] != -1) /*合法的文件描写叙述符*/
{
FD_SET(connect_host[i], &scanfd); /*放入集合*/
if(maxfd < connect_host[i]) /*更新最大文件描写叙述符值*/
{
maxfd = connect_host[i];
}
}
}
/*select等待*/
err = select(maxfd + 1, &scanfd, NULL, NULL, &timeout) ;
switch(err)
{
case 0: /*超时*/
break;
case -1: /*发生错误*/
break;
default: /*有可读套接字文件描写叙述符*/
if(connect_number<=0)
break;
for(i = 0;i<CLIENTNUM;i++)
{
/*查找激活的文件描写叙述符*/
if(connect_host[i] != -1)
if(FD_ISSET(connect_host[i],&scanfd))
{
memset(buff, 0, BUFFLEN);/*清零*/
n = recv(connect_host[i], 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(connect_host[i], buff, strlen(buff),0);
/*发送数据*/
}
/*更新文件描写叙述符在数组中的值*/
connect_host[i] = -1;
connect_number --; /*client计数器减1*/
/*关闭client*/
close(connect_host[i]);
}
}
break;
}
}
return NULL;
}
static void *handle_connect(void *argv)
{
int s_s = *((int*)argv) ; /*获得server侦听套接字文件描写叙述符*/
struct sockaddr_in from;
socklen_t len = sizeof(from);
/*接收client连接*/
for(;;)
{
int i = 0;
int s_c = accept(s_s, (struct sockaddr*)&from, &len);
/*接收client的请求*/
printf("a client connect, from:%s\n",inet_ntoa(from.sin_addr));
/*查找合适位置，将client的文件描写叙述符放入*/
for(i=0;i<CLIENTNUM;i++)
{
if(connect_host[i] == -1) /*找到*/
{
/*放入*/
connect_host[i]= s_c;
/*client计数器加1*/
connect_number ++;
/*继续轮询等待client连接*/
break;
}
}
}
return NULL;
}
int main(int argc, char *argv[])
{
int s_s; /*server套接字文件描写叙述符*/
struct sockaddr_in local; /*本地地址*/
int i = 0;
memset(connect_host, -1, CLIENTNUM);
/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);
/*初始化地址*/
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); /*serverport*/
/*将套接字文件描写叙述符绑定到本地地址和port*/
bind(s_s, (struct sockaddr*)&local, sizeof(local));
listen(s_s, BACKLOG); /*侦听*/
pthread_t thread_do[2];/*线程ID*/
/*创建线程处理client连接*/
pthread_create(&thread_do[0], /*线程ID*/
NULL, /*属性*/
handle_connect, /*线程回调函数*/
(void*)&s_s); /*线程參数*/
/*创建线程处理client请求*/
pthread_create(&thread_do[1], /*线程ID*/
NULL, /*属性*/
handle_request, /*线程回调函数*/
NULL); /*线程參数*/
/*等待线程结束*/
for(i=0;i<2;i++)
pthread_join(thread_do[i], NULL);
close(s_s);
return 0;
}选择合适的server模型十分重要。对于编程有非常大的影响。
Linux C语言 网络编程（二） server模型的更多相关文章
- Linux网络编程(二)
Linux网络编程(二) 使用多进程实现服务器并发访问. 采用多进程的方式实现服务器的并发访问的经典范例. 程序实现功能: 1.客户端从标准输入读入一行文字,发送到服务器. 2.服务器接收到客户端发来 ...
- 7)Linux程序设计入门--网络编程
)Linux程序设计入门--网络编程 Linux系统的一个主要特点是他的网络功能非常强大.随着网络的日益普及,基于网络的 应用也将越来越多. 在这个网络时代,掌握了Linux的网络编程技术,将令每一个 ...
- 11. Go 语言网络编程
Go 语言网络编程 Go语言在编写 web 应用方面非常得力.因为目前它还没有 GUI(Graphic User Interface 图形化用户界面)的框架,通过文本或者模板展现的 html 界面是目 ...
- Linux下TCP网络编程与基于Windows下C#socket编程间通信
一.linux下TCP网络编程基础,需要了解相关函数 Socket():用于套接字初始化. Bind():将 socket 与本机上的一个端口绑定,就可以在该端口监听服务请求. Listen():使s ...
- java网络编程socket\server\TCP笔记（转）
java网络编程socket\server\TCP笔记(转) 2012-12-14 08:30:04| 分类: Socket | 标签:java |举报|字号 订阅 1 TCP的开销 a ...
- Linux高并发网络编程开发——10-Linux系统编程-第10天（网络编程基础-socket）
在学习Linux高并发网络编程开发总结了笔记,并分享出来.有问题请及时联系博主:Alliswell_WP,转载请注明出处. 10-Linux系统编程-第10天(网络编程基础-socket) 在学习Li ...
- Linux 网络编程（IO模型）
针对linux 操作系统的5类IO模型,阻塞式.非阻塞式.多路复用.信号驱动和异步IO进行整理,参考<linux网络编程>及相关网络资料. 阻塞模式 在socket编程(如下图)中调用如下 ...
- Linux 网络编程二（Socket创建）
TCP通信 一个程序使用套接字需要执行4个步骤. --分配套接口和初始化 --连接 --发送或接收数据 --关闭套接字 涉及到的调用包括socket.bind.listen.connect(阻塞线程) ...
- C语言网络编程（Linux && Windows）（1）
和朋友一起做课程设计,同时学习C语言的网络编程,以前写的都是python网络编程,但python很多的库都是封装好的,大部分人在使用的时候不会去了解底层的实现,这样对长远的学习不太好,也改正自己这方面 ...
随机推荐
- HDU1565方格取数
典型的状态压缩DP问题.第i行的取法只受到第i-1行的影响.首先每一行的取法要相容(不能有两个相邻),然后相邻行之间也要相容.将每一个格子看做两种状态,1表示取,0表示不取.这样每一行就是一个01串, ...
- hdu1862
//开始把student stu[100000]放置在main()中导致栈溢出,所以必须放在全局位置, //可以调用数组的排序函数sort,包含头文件#include<algorithm> ...
- Youtube深度学习推荐系统论文
https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45530.pdf https://zh ...
- New Ubuntu 16.04 Server Checklist
新的云服务器需要进行一些配置和安装一些软件,推荐Digitalocean社区的一些教程 服务器配置(包括SSH,安全设置):https://www.digitalocean.com/community ...
- 使用Powermock和mockito来进行单元测试
转载:http://blog.csdn.net/u013428664/article/details/44095889 简介 Mockito是一个流行的Mocking框架.它使用起来简单,学习成本很低 ...
- Linux程序
1.如何找到一个进程的安装程序目录与启动目录 2.如何完全卸载一个程序
- 席位分配问题——惯例Q值法和d'hondt法的MATLAB程序
本篇博文为追忆以前写过的算法系列第四篇 温故知新 本篇于2009年发表于百度博客,当时还没接触CSDN.所以是文学和技术博客混淆,只是这个程序博文訪问量突破2000,有不少网友评论互动.应该 ...
- 撸代码--linux进程通信（基于共享内存）
1.实现亲缘关系进程的通信,父写子读 思路分析:1)首先我们须要创建一个共享内存. 2)父子进程的创建要用到fork函数.fork函数创建后,两个进程分别独立的执行. 3)父进程完毕写的内容.同一时候 ...
- PHP增加$_ENV变量
在日常开发过程中,我们常常会将一些系统或模块配写在配置文件里.这样便于程序维护与修改.通常的配置文件有.ini , .xml等.配置文件的好处在于:1,便于管理.2,可读性高.但是,使用配置文件也会有 ...
- HDU 小明系列故事——师兄帮帮忙 高速幂
小明系列故事--师兄帮帮忙 Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others) To ...