多进程服务器端

最新推荐文章于 2024-10-10 13:45:00 发布
最新推荐文章于 2024-10-10 13:45:00 发布
阅读量96 收藏
点赞数
分类专栏： 网络编程 文章标签： c语言 网络 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45767431/article/details/127753035
版权

  拥有2个运算器的CPU称作双核CPU,拥有4个运算器的CPU称作4核CPU。核的个数与可同时运行的进程数相同。

通过fork函数创建进程

fork函数创建调用的进程副本，两个进程都将执行fork函数返回后的语句。 

#include <stdio.h>
#include <unistd.h>
int gval=10;

int main(int argc, char *argv[])
{
    pid_t pid;
    int lval=20;
    gval++, lval+=5;

    pid=fork();
    if(pid==0)	// if Child Process
        gval+=2, lval+=2;
    else			// if Parent Process
        gval-=2, lval-=2;

    if(pid==0)
        printf("Child Proc: [%d, %d] \n", gval, lval);
    else
        printf("Parent Proc: [%d, %d] \n", gval, lval);
    return 0;
}

 

进程和僵尸进程 

  一个已经终止但是其父进程尚未对其进行善后处理（获取终止子进程的有关信息，释放它仍占用的资源）的进程称为僵尸进程(zombie)。

产生僵尸进程的原因

  向exit函数传递的参数值和main函数的return语句返回的值都会传递给操作系统。而操作系统不会销毁子进程，直到把这些值传递给产生该子进程的父进程。处在这种状态下的进程就是僵尸进程。也是就说，将子进程变成僵尸进程的正是操作系统。

  操作系统不会主动把这些值传递给父进程，只有父进程主动发起请求（函数调用）时，操作系统才会传递该值。如果父进程未主动要求获得子进程的结束状态值，操作系统将一直保存，并让子进程长时间处于僵尸进程状态。

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    pid_t pid=fork();

    if(pid==0)     // if Child Process
    {
        puts("Hi I'am a child process");
    }
    else
    {
        printf("Child Process ID: %d \n", pid);
        sleep(100);     // Sleep 30 sec.
    }

    if(pid==0)
        puts("End child process");
    else
        puts("End parent process");
    return 0;
}

父进程暂停30秒，如果父进程终止，处于僵尸状态的子进程将同时被销毁。 

 销毁僵尸进程1：利用wait函数

//wait.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    int status;
    pid_t pid=fork();

    if(pid==0)
    {
        return 3; //终止子进程
    }
    else
    {
        printf("Child PID: %d \n", pid);
        pid=fork();
        if(pid==0)
        {
            exit(7); //终止子进程
        }
        else
        {
            printf("Child PID: %d \n", pid);
            wait(&status);  //将之间终止的子进程信息保存到status变量，同时相关子进程被完全销毁
            if(WIFEXITED(status))
                printf("Child send one: %d \n", WEXITSTATUS(status));

            wait(&status);
            if(WIFEXITED(status))
                printf("Child send two: %d \n", WEXITSTATUS(status));
            sleep(30);     // Sleep 30 sec.
        }
    }
    return 0;
}

  调用wait函数时，如果没有已终止的子进程，那么程序将阻塞直到有子进程终止，因此需谨慎调用该函数。

销毁僵尸进程2：使用waitpid函数 

 更多参数相关细节可参考《unix环境高级编程》

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char *argv[])
{
    int status;
    pid_t pid=fork();

    if(pid==0)
    {
        sleep(15);
        return 24;
    }
    else
    {
        while(!waitpid(-1, &status, WNOHANG))
        {
            sleep(3);
            puts("sleep 3sec.");
        }

        if(WIFEXITED(status))
            printf("Child send %d \n", WEXITSTATUS(status));
    }
    return 0;
}

信号处理

  此处的“信号”是在特定事件发生时由操作系统向进程发送的消息。为了响应该消息，执行与消息相关的自定义操作的过程称为“处理”或“信号处理”。

信号和signal函数

  调用该函数时，第一个参数为特殊情况信息，第二个参数为特殊情况下将要调用的函数的地址值（指针）,第二个参数的int形参就是收到的信号值。发生第一个参数代表的情况时，调用第二个参数所指的函数。

signal函数中注册的部分特殊情况和对应的常数:

alarm函数：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig) //信号处理函数（信号处理器）
{
	if(sig==SIGALRM)
		puts("Time out!");

	alarm(10);
}
void keycontrol(int sig)
{
	if(sig==SIGINT)
		puts("CTRL+C pressed");
}

int main(int argc, char *argv[])
{
	int i;
	signal(SIGALRM, timeout);
	signal(SIGINT, keycontrol);
	alarm(10);

	for(i=0; i<3; i++)
	{
		puts("wait...");
		sleep(100);
	}
	return 0;
}

 产生信号时，为了调用信号处理器，将唤醒由于调用sleep函数而进入阻塞状态的进程。而且，进程一旦被唤醒，就不会再进入（由上一次调用sleep导致的）睡眠状态。

利用sigaction函数进行信号处理

  sigaction函数完全可以替代signal函数，而且更稳定，因为signal函数在UNIX的不同操作系统中可能存在区别，但sigaction函数完全相同。

 sa_handler成员保存信号处理函数的指针值（地址值）。sa_mask和sa_flags用于指定信号相关的选项和特性。（我看网上对这个结构体的定义与书上的不同，先在这儿做个注释，书上后续的内容可能会有补充）

sigaction函数的示例：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig)
{
	if(sig==SIGALRM)
		puts("Time out!");
	alarm(2);	
}

int main(int argc, char *argv[])
{
	int i;
	struct sigaction act;
	act.sa_handler=timeout;
	//int sigemptyset(sigset_t *set) 将信号集初始化为空
	sigemptyset(&act.sa_mask);  //将sa_mask成员的所有位初始化为0
	act.sa_flags=0;
	sigaction(SIGALRM, &act, 0);

	alarm(2);

	for(i=0; i<3; i++)
	{
		puts("wait...");
		sleep(100);
	}
	return 0;
}

利用信号处理技术消灭僵尸进程

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

void read_childproc(int sig)
{
	int status;
	pid_t id=waitpid(-1, &status, WNOHANG);
	if(WIFEXITED(status))
	{
		printf("Removed proc id: %d \n", id);
		printf("Child send: %d \n", WEXITSTATUS(status));
	}
}

int main(int argc, char *argv[])
{
	pid_t pid;
	struct sigaction act;
	act.sa_handler=read_childproc;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	sigaction(SIGCHLD, &act, 0);

	pid=fork();
	if(pid==0)
	{
		puts("Hi! I'm child process");
		sleep(10);
		return 12;
	}
	else
	{
		printf("Child proc id: %d \n", pid);
		pid=fork();
		if(pid==0)
		{
			puts("Hi! I'm child process");
			sleep(10);
			exit(24);
		}
		else
		{
			int i;
			printf("Child proc id: %d \n", pid);
			for(i=0; i<5; i++)
			{
				puts("wait...");
				sleep(5);
			}
		}
	}
	return 0;
}

基于多任务的并发服务器

   每当有客户端请求服务时（连接请求），服务器端都创建子进程以提供服务。

 调用fork函数后，父进程将文件描述符复制给子进程，而不是套接字。套接字并非进程所有，而是属于操作系统，只是进程拥有代表相应套接字的文件描述符。只有当套接字对应的文件描述符都销毁后，才能销毁套接字。因此，调用fork函数后，要将无关的套接字文件描述符关掉。

 

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);
void read_childproc(int sig);

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;

    pid_t pid;
    struct sigaction act;
    socklen_t adr_sz;
    int str_len, state;
    char buf[BUF_SIZE];
    if(argc!=2) {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    act.sa_handler=read_childproc;  //设置信号处理函数
    sigemptyset(&act.sa_mask);
    act.sa_flags=0;
    state=sigaction(SIGCHLD, &act, 0);
    serv_sock=socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_adr.sin_port=htons(atoi(argv[1]));

    if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
        error_handling("bind() error");
    if(listen(serv_sock, 5)==-1)
        error_handling("listen() error");

    while(1)
    {
        adr_sz=sizeof(clnt_adr);
        clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
        if(clnt_sock==-1)
            continue;
        else
            puts("new client connected...");
        pid=fork();  //有新的连接请求时创建子进程
        if(pid==-1)
        {
            close(clnt_sock);
            continue;
        }
        if(pid==0)
        {
            close(serv_sock);  //关闭父进程传递的用于监听的文件描述符
            while((str_len=read(clnt_sock, buf, BUF_SIZE))!=0)
                write(clnt_sock, buf, str_len);

            close(clnt_sock);
            puts("client disconnected...");
            return 0;
        }
        else
            close(clnt_sock);  //关闭传递给子进程的文件描述符
    }
    close(serv_sock);
    return 0;
}

void read_childproc(int sig)
{
    pid_t pid;
    int status;
    pid=waitpid(-1, &status, WNOHANG);
    printf("removed proc id: %d \n", pid);
}
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

分割TCP的I/O程序

 分割I/O程序优点：1.程序实现更加简单，读写可以分别在父进程与子进程中实现

2.提高频繁交换数据的程序性能

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);
void read_routine(int sock, char *buf);
void write_routine(int sock, char *buf);

int main(int argc, char *argv[])
{
	int sock;
	pid_t pid;
	char buf[BUF_SIZE];
	struct sockaddr_in serv_adr;
	if(argc!=3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	sock=socket(PF_INET, SOCK_STREAM, 0);  
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_adr.sin_port=htons(atoi(argv[2]));
	
	if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
		error_handling("connect() error!");

	pid=fork();
	if(pid==0)
		write_routine(sock, buf);
	else 
		read_routine(sock, buf);

	close(sock);
	return 0;
}

void read_routine(int sock, char *buf)
{
	while(1)
	{
		int str_len=read(sock, buf, BUF_SIZE);
		if(str_len==0)
			return;

		buf[str_len]=0;
		printf("Message from server: %s", buf);
	}
}
void write_routine(int sock, char *buf)
{
	while(1)
	{
		fgets(buf, BUF_SIZE, stdin);
		if(!strcmp(buf,"q\n") || !strcmp(buf,"Q\n"))
		{	
			shutdown(sock, SHUT_WR);  //通过shutdown向服务器发送
			return;
		}
		write(sock, buf, strlen(buf));
	}
}
void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

close和shutdown的具体细节可以参考这篇文章，写的很好：tcp - close和shutdown关闭TCP连接_个人文章 - SegmentFault 思否

weixin_45767431
关注
专栏目录
多进程服务器端1
08-08
本文将详细介绍一种多进程服务器端的实现，并涉及相关的进程管理知识，包括如何创建进程、处理僵死进程以及利用wait函数回收子进程。 首先，多进程服务器是一种常见的并发服务器实现模型，通过创建多个独立的进程来...
网络编程 -- 实现多进程并发回声服务器
玛卡巴卡的博客
05-07 356
回声服务器：客户端给服务端发啥，服务端就给客户端返回啥 多进程：每当服务器受到新的请求时，服务器当前进程（父进程）利用 fork() 函数复制一个子进程出来，处理客户端的请求，父进程继续监听新的请求。 销毁僵尸进程：利用 sigaction 函数进行信号处理，当子进程终止时将产生 SIGCHLD 信号，触发调用 read_childproc 函数，在read_childproc 函数内， 使用 waitpid 函数销毁子进程， 避免其编程僵尸进程。
网络编程（15）—— 实现利用管道保存客户端数据的socket服务端
Hyman的博客
10-11 2074
#include #include #include #include #include #include #include #include #define BUF_SIZE 30 void error_handling(char* message); void read_childproc(int sig); int main(int argc,char* argv[]) { st
网络编程——进程编程
LSYZWF的博客
04-25 582
文章目录目的内容实验代码及结果 目的 （1）在理解进程的概念及其生命周期和状态转换过程的基础上，进行进程相关编程； （2）在理解进程间通信的基本原理的基础上，编程实现进程间通信。 内容 （1）在Linux中利用fork()在父进程A中创建一个子进程B，再在子进程B中创建一个子进程C，在3个进程中都要编写适当的语句模拟进程的工作。 （2）创建子进程时将复制父进程的所有内容，此时的复制对象也包含套接字文件描述符。编写程序验证复制的文件描述符整数值是否与原文件描述符整数值相同。 （3）如果在未注册SIGIN
TCP/IP网络编程学习记录一
qq_41264992的博客
07-01 135
博客说明：本博客为了记录博主学习TCP/IP网络编程的知识点和个人理解，上面的很多术语和图片都来自书上,环境是Linux 目录一、Socket补充一、网络字节顺序与本地字节顺序之间的转换函数补充二、UDP与TCP在这部分的区别 一、Socket 偷懒，这里放一篇专门讲解socket的博客，讲的很详细，先看这个socket技术详解链接 因为这篇博客把常用到的socket都讲到了，而且说的很好，所以这里只写一点简单的补充。 补充一、网络字节顺序与本地字节顺序之间的转换函数 cpu向内存保存数据的方式有两.
网络编程 笔记（六） 多进程服务器
时空矩阵
10-21 762
进程－ 进程（Process）：“占用内存空间的正在运行的程序” － 进程ID ：操作系统给进程分配的id，其值大于2，1要分配给操作系统启动后的首个进程 －linux查看进程的命令：ps au ；参数a和u列出所有进程的详细信息通过fork函数创建进程父进程：fork函数返回子进程的进程id 子进程：fork函数返回0 例子// // main.c // echo_mpserv
多进程服务器端全部程序
02-06
在IT行业中，网络编程是构建分布式系统和网络应用程序的基础，其中多进程服务器端程序是实现高并发、高性能服务的关键技术之一。本项目“多进程服务器端全部程序”聚焦于利用多进程模型来设计和实现一个服务器端应用...
多进程并发服务器实现
04-04
在服务器端，我们需要创建一个监听套接字，通过`bind()`函数绑定到特定的IP地址和端口号，然后使用`listen()`函数开始监听连接请求。当有新的客户端连接时，服务器通过`accept()`函数接收连接，并为每个连接创建一个...
多进程服务器实例.
09-21
### 多进程服务器实例分析 #### 一、概述 在计算机网络编程中，服务器往往需要同时处理多个客户端的请求。为了提高效率和服务质量，多进程并发服务器成为了一种常见的解决方案。本文将通过一个具体的C语言实现案例...
多进程并发服务器设计
04-04
进程间通信（IPC）是设计多进程服务器的另一个关键技术点。在Linux中，进程间通信可以通过多种方式实现，比如管道（pipe）、消息队列（message queue）、共享内存（shared memory）和信号量（semaphore）等。在提供...
Linux网络编程 - 多进程服务器端（2）
yunfan
01-08 1068
实现一个多进程的服务器端程序。
C/C++复习（一）
2301_79813267的博客
10-04 1337
指向的函数返回类型 （*函数名）（指向的函数的参数类型与个数）数组指针：表示一个指针，但是指向的是一个数组。指针数组：表示的是一个数组，但是数组的元素都是指针。sizeof是在编译时就确定结果的。
C（十五）函数综合（一）--- 开公司吗？
2401_87025655的博客
10-07 1291
C（十五）函数综合（一）
【2024版】最新kali linux入门及常用简单工具介绍（非常详细）零基础入门到精通，收藏这一篇就够了_kalilinux
weixin_57514792的博客
10-07 1165
最新kali linux入门及常用简单工具介绍
Macbook ToDesk 无法连接网络
Primer5
10-04 337
检查登录项，看到后台运行项目是关闭状态，允许后台运行之后返回查看立马显示网络连接正常。网络连接的是 Wi-Fi，打开浏览器能跟正常浏览内容，说明 Wi-Fi 是正常的。检查防火墙是没有阻止ToDesk 的任何连接，说明防火墙也是正常的。
网络风暴产生原因、危害、预防和解决方法
luotuo28的博客
10-09 383
网络风暴是指由于某种原因引发的网络中数据流量急剧增加，导致网络性能严重下降甚至瘫痪的现象。
网络安全学习路线图（2024版详解）
最新发布
baimaozi008的博客
10-10 575
近期，大家在网上对于网络安全讨论比较多，想要学习的人也不少，但是需要学习哪些内容，按照什么顺序去学习呢？其实我们已经出国多版本的路线图，一直以来效果也比较不错，本次我们针对市场需求，整理了一套系统的路线图，供大家学习参考。希望大家按照路线图进行系统学习不仅可以的完成上岸，还能够系统化学习，提升自己的后期竞争力。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 438
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
网络扫描模块python-nmap案例解析
we chat：玩转测试开发
10-07 453
它可以方便地在 Python 脚本中执行网络扫描，并解析 Nmap 的输出结果。python-nmap 模块是进行网络扫描的强大工具，通过简单的接口和丰富的功能，开发者可以轻松地在 Python 中集成网络安全检查和资产发现功能。6.1执行扫描：在 run_nmap_scan 函数中，创建了一个 nmap.PortScanner 实例，并使用 scan() 方法执行网络扫描。6.2 解析结果：扫描结果通过访问 scanner.all_hosts() 方法获取，并打印每个主机的状态和开放的端口信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值