多进程、多线程并发服务器代码

1.单进程服务器：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<sys/types.h>
 4 #include<sys/socket.h>
 5 #include<string.h>
 6 #include<strings.h>
 7 #include<ctype.h>
 8 #include<arpa/inet.h>
 9 #include<unistd.h>
10
11 #define SERV_PORT 8888
12
13 int std_err(const char* name)
14 {
15     perror(name);
16     exit(1);
17 }
18
19 int main(void)
20 {
21     int sfd, cfd, ret;
22     int len;
23     socklen_t clie_len;
24     char buf[BUFSIZ];
25     //创建服务器套节字
26     sfd = socket(AF_INET, SOCK_STREAM, 0);
27     if(sfd == -1)
28         std_err("socket");
29     //定义地址类型
30     struct sockaddr_in serv_addr, clie_addr;
31     serv_addr.sin_family = AF_INET;
32     serv_addr.sin_port = htons(SERV_PORT);
33     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
34
35     //绑定服务器的IP、端口；
36     ret = bind(sfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
37     if(ret == -1)
38         std_err("bind");
39
40     //监听链接服务器的客户数量
41     ret = listen(sfd, 99);
42     if(ret == -1)
43         std_err("listen");
44     clie_len = sizeof(clie_addr);
45     //阻塞等待客户端发起链接请求
46     cfd = accept(sfd, (struct sockaddr*)&clie_addr, &clie_len);
47     if(cfd == -1)
48         std_err("accept");
49
50     //传输数据
51     while(1)
52     {
53         len = read(cfd, buf, sizeof(buf));
54         printf("server: %s\n", buf);
55         int i;
56         for(i = 0; i < len; i++)
57             buf[i] = toupper(buf[i]);
58         write(cfd, buf, len);
59     }
60     close(sfd);
61     close(cfd);
62     return 0;
63 }

2.单客户端

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<sys/types.h>
 4 #include<sys/socket.h>
 5 #include<string.h>
 6 #include<strings.h>
 7 #include<ctype.h>
 8 #include<arpa/inet.h>
 9 #include<unistd.h>
10
11 #define SERV_PORT 8888
12
13 int std_err(const char* name)
14 {
15     perror(name);
16     exit(1);
17 }
18
19 int main(void)
20 {
21     int cfd, ret, serv_IP;
22     char buf[BUFSIZ];
23     //创建套节字
24     cfd = socket(AF_INET, SOCK_STREAM, 0);
25     if(cfd == -1)
26         std_err("socket");
27     //定义IP ， 端口
28     struct sockaddr_in clie_addr;
29     clie_addr.sin_family = AF_INET;
30     clie_addr.sin_port = htons(SERV_PORT);
31     //转换IP 字符串的地址
32     ret = inet_pton(AF_INET, "192.168.22.251", &serv_IP);
33     if(ret != 1)
34         std_err("inet_pton");
35     clie_addr.sin_addr.s_addr = serv_IP;
36     //链接服务器
37     ret = connect(cfd, (struct sockaddr*)&clie_addr, sizeof(clie_addr));
38     if(ret == -1)
39         std_err("connect");
40     // 传输数据
41     while(1)
42     {
43         int len = read(STDIN_FILENO, buf, sizeof(buf));
44         printf("cliet_len: %d\n", len);
45
46         write(cfd, buf, len);
47         len = read(cfd, buf, sizeof(buf));
48         printf("serve_len: %d\n", len);
49         printf("%s",buf);
50         //write(STDOUT_FILENO, buf, len);
51     }
52     //关闭套节字
53     close(cfd);
54     return 0;
55
56 }

3.多进程服务器

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<sys/types.h>
  4 #include<sys/socket.h>
  5 #include<string.h>
  6 #include<strings.h>
  7 #include<ctype.h>
  8 #include<arpa/inet.h>
  9 #include<unistd.h>
 10 #include<errno.h>
 11 #include<sys/wait.h>
 12 #include<errno.h>
 13
 14 #define SERV_PORT 8883
 15
 16 int std_err(const char* name)
 17 {
 18     perror(name);
 19     exit(1);
 20 }
 21
 22 void do_sth_child(int signum)
 23 {
 24
 25     while(waitpid(0, NULL, WNOHANG) < 0)
 26         ;
 27
 28 }
 29
 30 int main(void)
 31 {
 32     int sfd, cfd, ret;
 33     int len;
 34     pid_t pid;
 35     socklen_t clie_len;
 36     char buf[BUFSIZ], clibuf[32];
 37     //创建服务器套节字
 38     sfd = socket(AF_INET, SOCK_STREAM, 0);
 39     if(sfd == -1)
 40         std_err("socket");
 41     //定义地址类型
 42     struct sockaddr_in serv_addr, clie_addr;
 43     serv_addr.sin_family = AF_INET;
 44     serv_addr.sin_port = htons(SERV_PORT);
 45     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 46
 47     //绑定服务器的IP、端口；
 48     ret = bind(sfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
 49     if(ret == -1)
 50         std_err("bind");
 51
 52     //监听链接服务器的客户数量
 53     ret = listen(sfd, 99);
 54     if(ret == -1)
 55         std_err("listen");
 56     clie_len = sizeof(clie_addr);
 57     while(1)
 58     {
 59         //阻塞等待客户端发起链接请求
 60         cfd = accept(sfd, (struct sockaddr*)&clie_addr, &clie_len);
 61         printf("client IP :%s, port: %d\n",
 62                 inet_ntop(sfd, &clie_addr.sin_addr.s_addr, clibuf, sizeof(clibuf)),
 63                ntohs(clie_addr.sin_port) );
 64         if(cfd == -1)
 65             std_err("accept");
 66         pid = fork();
 67         if(pid < 0)
 68             std_err("fork:");
 69         else if(pid == 0)
 70         {
 71             close(sfd);
 72             break;
 73         }
 74         else        //住进程实现逻辑；1.回收子进程，2，关闭不必要的文件描述父 3,继续等待客户端链接，如果有，则继续创建子进程
 75         {
 76             close(cfd);
 77             signal(SIGCHLD, do_sth_child);
 78         }
 79     }
 80     if(pid == 0)
 81     {
 82 agian:
 83         //子进程传输数据
 84         while(1)
 85         {
 86             len = read(cfd, buf, sizeof(buf));
 87             if(len == 0)    //即客户端关闭通信，
 88             {
 89                 close(cfd);
 90                 exit(1);
 91             }
 92             else if( len == -1)
 93             {
 94                 if(errno == EINTR)
 95                 {
 96                     goto agian;
 97                 }
 98                 else
 99                 {
100                     std_err("read:");
101                 }
102             }
103             else
104             {
105                 int i;
106                 for(i = 0; i < len; i++)
107                     buf[i] = toupper(buf[i]);
108                 write(cfd, buf, len);
109                 write(STDOUT_FILENO, buf, len);
110             }
111         }
112     }
113
114     return 0;
115 }

4.多个客户端(一段代码产生多个客户端)

　　1.当时编写这段代码的作用是撑爆老师的服务器

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<sys/types.h>
  4 #include<sys/socket.h>
  5 #include<string.h>
  6 #include<strings.h>
  7 #include<ctype.h>
  8 #include<arpa/inet.h>
  9 #include<unistd.h>
 10 #include<sys/wait.h>
 11 #include<signal.h>
 12 #include<errno.h>
 13 #include<pthread.h>
 14 #include <pthread.h>
 15
 16
 17 #define SERV_PORT 8883
 18 #define SERV_IP "127.0.0.1"
 19 int std_err(const char* name)
 20 {
 21     perror(name);
 22     exit(1);
 23 }
 24 void do_sth_child(int signum)
 25 {
 26     while(waitpid(0, NULL, WNOHANG) > 0);
 27 }
 28
 29 int main(void)
 30 {
 31     int cfd, ret;
 32     char buf[BUFSIZ];
 33     pid_t pid;
 34     //pthread_mutexattr_t mattr;
 35     //pthread_mutexattr_init(&mattr);
 36     //pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
 37     //pthread_mutex_t mutex;
 38     //pthread_mutex_init(&mutex, &mattr);
 39
 40     int i;
 41     for(i = 0; i < 6; i++){
 42         pid = fork();
 43         if(pid == 0)
 44             break;
 45         else if(pid < 0)
 46             std_err("fork");
 47         else
 48         {
 49             // close(cfd);
 50             signal(SIGCHLD, do_sth_child);
 51         }
 52     }
 53
 54     //子进程逻辑
 55     if(pid == 0)
 56     {
 57         //创建套节字
 58         cfd = socket(AF_INET, SOCK_STREAM, 0);
 59         if(cfd == -1)
 60             std_err("socket");
 61         //定义IP ， 端口
 62         struct sockaddr_in clie_addr;
 63         clie_addr.sin_family = AF_INET;
 64         clie_addr.sin_port = htons(SERV_PORT);
 65         //转换IP 字符串的地址
 66         ret = inet_pton(AF_INET, SERV_IP, &clie_addr.sin_addr.s_addr);
 67         if(ret != 1)
 68             std_err("inet_pton");
 69         //pthread_mutex_lock(&mutex);
 70         //链接服务器
 71         ret = connect(cfd, (struct sockaddr*)&clie_addr, sizeof(clie_addr));
 72         if(ret == -1)
 73             std_err("connect");
 74         // 传输数据
 75         // while(1)
 76         {
 77             int len;
 78 again:
 79             //char bufstr[10] = "sdasdasd";
 80             len = read(STDIN_FILENO, buf, sizeof(buf));
 81             if(len < 0)
 82             {
 83                 if(errno == EAGAIN || errno == EINTR)
 84                     goto again;
 85                 else
 86                     std_err("read");
 87             }
 88             write(cfd, buf, len);
 89             //write(cfd, bufstr, sizeof(bufstr));
 90             //len = read(cfd, buf, sizeof(buf));
 91             //printf("serve_len: %d\n", len);
 92             //printf("%s",buf);
 93             write(STDOUT_FILENO, buf, len);
 94         }
 95         //pthread_mutex_unlock(&mutex);
 96     }
 97     while(1);
 98     //关闭套节字
 99     close(cfd);
100     return 0;
101
102 }

时间： 2024-10-24 11:34:35

多进程、多线程并发服务器代码的相关文章

linux网络编程----->高并发--->多线程并发服务器

做网络服务的时候并发服务端程序的编写必不可少.前端客户端应用程序是否稳定一部分取决于客户端自身,而更多的取决于服务器是否相应时间够迅速,够稳定．常见的linux并发服务器模型: 多进程并发服务器多线程并发服务器 select多路I/O转接服务器 poll多路I/O转接服务器 epool多路I/O转接服务器．本次主要讨论多线程并发服务器模型: 使用多线程模型开发服务时需要考虑以下问题 1. 调整进程内最大文件描述符上限. 2. 线程如有共享数据, 考虑线程同步. 3. 服务于客户端线程

多进程实现并发服务器（TCP）

前提:基于Linux系统的学习 /*多进程实现并发服务器父进程任务 1.从未决连接队列中取出请求,建立和客户端的连接,cfd 2.创建子进程 3.close(cfd) 4.负责子进程的收尸工作子进程的任务 1.close(sfd) 2.子进程负责处理客户端消息 close(sfd) exit(0) */ #include <stdio.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h>

TCP socket 多线程并发服务器（发送）与客户端（接收）

实现功能:Ubuntu上通过多线程实现服务器并发给客户端发送文件,携带包头,根据包头信息命名新文件.适用于短连接. 问题小结: 01. 调用嵌套在结构体中的结构体char 数组成员时,需要动态分配内存. 02. 使用select() 监听socket变化.select() 其中三个参数分别监听读,写,出错. 03. 每条线程在同时发送文件时,需要使用独立的变量,如accept(), FILE *fd, *buff 等,用结构数组 + 标号实现. 04. struct stat stat_buff

Python学习笔记（六）多进程实现并发服务器

这个相对于多进程更加简单,每accept一个新的连接就创建一个新的线程.代码如下: # coding: utf-8 import socket import sys import errno import threading from time import ctime class ClientThread(threading.Thread): def __init__(self, client_socket, client_address): threading.Thread.__init__

Python学习笔记（五）多进程实现并发服务器

每创建一个TCP连接,就创建一个进程. 代码如下: # coding: utf-8 import socket import os import sys import signal import errno from time import ctime def hanlde_sigchld(a, b): (pid, status) = os.wait() print 'Child %d Finish, status = %d' % (pid, status) def handle_conne

linux网络编程----->高并发--->多进程并发服务器

在做网络服务的时候并发服务端程序的编写必不可少.前端客户端应用程序是否稳定一部分取决于客户端自身,而更多的取决于服务器是否相应时间够迅速,够稳定．常见的linux并发服务器模型: 多进程并发服务器多线程并发服务器 select多路I/O转接服务器 poll多路I/O转接服务器 epool多路I/O转接服务器．本次主要讨论多线程并发服务器模型: 使用多进程并发服务器时要考虑以下几点: 父进程最大文件描述个数(父进程中需要close关闭accpet返回的新文件描述符) 系统内创建进程个数(与内

Linux网络编程——tcp并发服务器（多线程）

tcp多线程并发服务器多线程服务器是对多进程服务器的改进,由于多进程服务器在创建进程时要消耗较大的系统资源,所以用线程来取代进程,这样服务处理程序可以较快的创建.据统计,创建线程与创建进程要快 10100 倍,所以又把线程称为"轻量级"进程.线程与进程不同的是:一个进程内的所有线程共享相同的全局内存.全局变量等信息,这种机制又带来了同步问题. tcp多线程并发服务器框架: 我们在使用多线程并发服务器时,直接使用以上框架,我们仅仅修改client_fun()里面的内容. 代码示例: #

Linux 高并发服务器

高并发服务器一.多进程并发服务器 1. 实现示意图 2. 使用多进程并发服务器时要考虑以下几点: 父进程最大文件描述个数(父进程中需要close关闭accept返回的新文件描述符) 系统内创建进程个数(与内存大小相关) 进程创建过多是否降低整体服务性能(进程调度) 3. 使用多进程的方式, 解决服务器处理多连接的问题: (1)共享读时共享, 写时复制文件描述符内存映射区 -- mmap (2)父进程的角色是什么? 等待接受客户端连接 -- accept 有链接: 创建一

Linux统系统开发11 Socket API编程2 多进程多线程高并发处理

[本文谢绝转载原文来自http://990487026.blog.51cto.com] <纲要> Linux统系统开发11 Socket API编程2 多进程多线程高并发处理 UDP服务器客户端最小模型,处理字符转大写 TCP 多进程并发服务器模型,为每个客户端开启一个进程: TCP 多线程服务器模型,使用wrap函数封装作业: ---------------------------------------------------- UDP服务器客户端最小模型,处理字符转大写 [em