基于LinuxC语言实现的TCP多线程/进程服务器

最新推荐文章于 2024-08-29 15:56:14 发布
最新推荐文章于 2024-08-29 15:56:14 发布
阅读量1.1k 收藏 4
点赞数
文章标签： 网络 tcp/ip linux 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72847002/article/details/132589964
版权

多进程并发服务器

设计流程

框架一（使用信号回收僵尸进程）

void handler(int sig)
{
    while(waitpid(-1, NULL, WNOHANG) > 0);
}

int main()
{
    //回收僵尸进程
    siganl(17, handler);
    //创建服务器监听套接字 server
    server = socket();
    //给服务器地址信息结构体赋值，并绑定
    bind();
    //监听指定端口，设置监听队列
    listen();
    
    while(1)
    {
        //创建与客户端通信的套接字
        client = accept();
        //创建子进程
        if(fork() == 0)
        {
            //关闭拷贝的服务器套接字
            close(server);
            while(1)
            {
                //接收消息
                recv();
                //发送消息
                send();
            }
            //通信结束关闭套接字
            close(client);
            //退出进程
            exit(0);
        }
        //关闭父进程的通信套接字
        close(client);
    }
    
    //服务器关闭
    close(server);
}

实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>

#define LOG(s) printf("[%s] {%s:%d} %s \n", __DATE__, __FILE__, __LINE__, s);

void cil(int client, struct sockaddr_in caddr);

void handler(int sig)
{
	while(waitpid(-1, NULL, WNOHANG) > 0);
}

int main(int argc, char *argv[])
{

	//回收僵尸进程
	signal(17, handler);
	//创建服务器
	int server = -1;
	if((server = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		LOG("socket error");
		return -1;
	}

	//给服务器地址信息结构体赋值，并绑定
	struct sockaddr_in saddr = {0};
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(8888);
	saddr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	if(bind(server, (struct sockaddr*)&saddr, sizeof(saddr)) == -1)
	{
		LOG("bind error");
		return -1;
	}

	//监听指定端口，设置监听队列
	if(listen(server, 5) == -1)
	{
		LOG("listen error");
		return -1;
	}

	puts("Tcp server start success");

	int client = -1;
	struct sockaddr_in caddr = {0};
	socklen_t len = sizeof(caddr);
	pid_t pid = -1;
	while(1)
	{
		//创建与客户端通信的套接字
		if((client = accept(server, (struct sockaddr*)&caddr, &len)) == -1)
		{
			LOG("accpet error");
			return -1;
		}

		printf("[%s/%d] client已上线\n", inet_ntoa(caddr.sin_addr), ntohl(caddr.sin_port));
		//创建子进程
		if((pid = fork()) < 0)
		{
			LOG("fork error");
			return -1;
		}
		else if(pid == 0)
		{
			cil(client, caddr);
			exit(0);
		}
		close(client);
	}

	close(server);

    return 0;
}

void cil(int client, struct sockaddr_in caddr)
{
	char buf[128] = "";
	int res = 0;
	while(1)
	{
		bzero(buf, sizeof(buf));
		if((res = read(client, buf, sizeof(buf))) < 0)
		{
			LOG("read error");
			break;
		}
		else if(res == 0)
		{
			printf("[%s/%d] client已下线\n", inet_ntoa(caddr.sin_addr), ntohl(caddr.sin_port));
			close(client);
			break;
		}
		printf("[%s/%d] client: %s\n", inet_ntoa(caddr.sin_addr), ntohl(caddr.sin_port), buf);
		
		bzero(buf, sizeof(buf));
		strcpy(buf, "ok");
		if(write(client, buf, sizeof(buf)) < 0)
		{
			LOG("write error");
			break;
		}
	}

}

框架二（使用孤儿进程机制避免僵尸进程产生）

int main()
{
    //创建服务器监听套接字 server
    server = socket();
    //给服务器地址信息结构体赋值，并绑定
    bind();
    //监听指定端口，设置监听队列
    listen();
    
    while(1)
    {
        //创建子进程
        if((pid = fork()) == 0)
        {
            //子进程创建用于与客户端通信的client
            client = accept();
            
            //创建孙进程
            if(pid = fork() == 0)
            {
                while(1)
                {
                    //孙进程负责与客户端通信
                    recv();
                    send();
                }
                //通信结束关闭套接字
                close(client);
                //退出进程
                exit(0);
            }
            //子进程
            else if(pid > 0)
            {
                //关闭多余的文件描述符
                close(server);
                close(client);
                //退出子进程
                exit(0);
            }
        }
        //父进程
        else if(pid > 0)
        {
            //回收子进程
            while(waitpid() == pid)
        }
    }
    //关闭文件描述符
    close(server);
}

实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>

#define LOG(s) printf("[%s] {%s:%d} %s\n", __DATE__, __FILE__, __LINE__, s);

void deal_cil_msg(int client, struct sockaddr_in caddr);

int main(int argc, char *argv[])
{
	//创建服务器socket
	int server = 0;
	if((server = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		LOG("socket error");
		return -1;
	}

	//绑定服务器IP和端口号
	//给地址信息结构体赋值
	struct sockaddr_in saddr = {0};
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(8888);
	saddr.sin_addr.s_addr = htonl(INADDR_ANY);

	if(bind(server, (struct sockaddr*)&saddr, sizeof(saddr)) == -1)
	{
		LOG("bind error");
		return -1;
	}

	//监听对应的端口号
	if(listen(server, 5) == -1)
	{
		LOG("listen error");
		return -1;
	}

	puts("server start success");

	//创建用于与客户端通信的socket
	struct sockaddr_in caddr = {0};
	int client = 0;
	socklen_t asize = sizeof(caddr);


	pid_t pid = -1;
	int status = 0;
	while(1)
	{
		//父进程只负责生儿子
		pid = fork();
		if(pid < 0)
		{
			LOG("fork error");
			return -1;
		}
		//子进程负责创建通信socket
		if(pid == 0)
		{
			//创建用于与客户端通信的socket
			if((client = accept(server, (struct sockaddr*)&caddr, &asize)) == -1)
			{
				LOG("accept error");
				return -1;
			}
			printf("[%s/%d]client已上线\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));

			//孙进程负责通信
			pid = fork();
			if(pid < 0)
			{
				LOG("fork error");
				return -1;
			}
			else if(pid == 0)
			{
				deal_cil_msg(client, caddr);
				close(client);
				exit(0);
			}
			else if(pid > 0)
			{
				close(server);
				close(client);
				//退出子进程
				exit(0);
			}
		}
		else if(pid > 0)
		{
			printf("wait child = %d\n", pid);
			//父进程等待子进程结束，准备收尸
			while(waitpid(pid, &status, 0) == pid)
			{
				printf("Parent is over - child: %d, status = %x\n", pid, status);
			}
		}
	}

	//关闭文件描述符
	close(server);
	
	return 0;
}


void deal_cil_msg(int client, struct sockaddr_in caddr)
{
	//接收消息
	char buf[128] = " ";

	while(1)
	{
		int len = 0;
		bzero(buf, sizeof(buf));
		if((len = recv(client, buf, sizeof(buf), 0)) < 0)
		{	
			LOG("recv error");
		}
		else if(len == 0)
		{
			printf("[%s/%d]client已下线\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
			break;
		}
		printf("[%s/%d]client: %s\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port), buf);

		bzero(buf, sizeof(buf));
		//发送消息
		strcpy(buf, "ok");
		write(client, buf, len);

	}


}

多线程并发服务器

设计流程

//线程参数结构体
typedef struct
{
	int client;
	struct sockaddr_in caddr;
} Client_msg;

int main()
{
    //创建服务器监听套接字 server
    server = socket();
    //给服务器地址信息结构体赋值，并绑定
    bind();
    //监听指定端口，设置监听队列
    listen();
    
    while(1)
    {
        //创建用于与客户端通信的套接字
        client = accpet();
        //创建线程
        pthread_create();
        while(1)
        {
            //读写
            //关闭文件描述符
            //退出线程
        }
        //解离线程
        pthread_detach();
    }
    //关闭文件描述符
    close(server);
}

实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <errno.h>

#define LOG(s) printf("[%s] {%s:%d} %s \n", __DATE__, __FILE__, __LINE__, s);

void* cil(void* arg);

//线程参数结构体
typedef struct
{
	int client;
	struct sockaddr_in caddr;
} Cli_msg;

int main(int argc, char *argv[])
{
	//创建服务器监听分套接字 server
	int server = -1;
	if((server = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		LOG("socket error");
		return -1;
	}

	//给服务器地址信息结构体赋值，并绑定
	struct sockaddr_in saddr = {0};
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(8899);
	saddr.sin_addr.s_addr = htonl(INADDR_ANY);

	if(bind(server, (struct sockaddr*)&saddr, sizeof(saddr)) == -1)
	{
		LOG("bind error");
		return -1;
	}

	//监听端口
	if(listen(server, 5) == -1)
	{
		LOG("listen error");
		return -1;
	}
	
	puts("tcp server start success");

	struct sockaddr_in caddr = {0};
	socklen_t len = sizeof(caddr);
	pthread_t tid = -1;
	int client = -1;
	Cli_msg cli_msg;
	while(1)
	{
		//创建用于与客户端通信的套接字 client
		if((client = accept(server, (struct sockaddr*)&caddr, &len)) == -1)
		{
			LOG("accept error");
			return -1;
		}

		printf("[%s/%d]client已上线\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
		cli_msg.client = client;
		cli_msg.caddr = caddr;
		//创建线程
		if(pthread_create(&tid, NULL, cil, &cli_msg) != 0)
		{
			LOG("pthread_create error");
			return -1;
		}
		pthread_detach(tid);
	}

	close(server);
	return 0;
}

void* cil(void* arg)
{
	int client = ((Cli_msg*)arg)->client;
	struct sockaddr_in caddr = ((Cli_msg*)arg)->caddr;

	char buf[128] = "";
	int res = 0;

	while(1)
	{
		bzero(buf, sizeof(buf));
		if((res = read(client, buf, sizeof(buf))) < 0)
		{
			LOG("read error");
			break;
		}
		else if(res == 0)
		{
			printf("[%s/%d]client已下线\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port));
			close(client);
			pthread_exit(NULL);
		}
		printf("[%s/%d]client: %s\n", inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port), buf);

		bzero(buf, sizeof(buf));
		strcpy(buf, "ok");

		if(write(client, buf, sizeof(buf)) < 0)
		{
			LOG("write error");
			break;
		}
	}

}
他人恐惧我贪婪
关注
Linux C++ 网络编程基础(2) : TCP多线程一个server对应多个client
琅嬛福地
08-10 1682
Linux POSIX线程库提供了一组函数来创建、管理和同步线程。：创建一个新的线程。return 0;：等待一个线程的结束。return 0;：初始化一个互斥锁。return 0;：初始化一个条件变量。return 0;
Linux c 基于TCP实现简单的文件服务器
RED_STARRR的博客
01-13 1913
关于TCP TCP协议作为传输层另一常用协议，强调传输数据的正确性，而一些文件传输并不需要过分追求实时性，而想要确保收到的文件没有损坏，想象一下，你发表一篇论文如果采用不可靠（相对）的UDP协议，假如其中一个公式的一个符号丢失或改变都将影响整篇论文。所以，在面对一些重要文件传输时因选择TCP，而音乐，视频等可以接受一定的损坏，可能只是丢几帧，并不影响整体体验，采用代价更小的UDP更好，以下代码仅考虑TCP。 文件传输 文件传输无非是把文件中所以数据拷贝到另一个空白文件当中， ...
Linux下c语言TCP多线程聊天室
Love丶伊卡洛斯
08-09 1072
开发环境：Linux，GCC 相关知识：TCP（博客：传送门），线程 附加：项目可能还有写不足之处，有些bug没调出来（如：对在线人数的控制），希望大佬赐教。 相关图片： 运行服务端 运行2个客户端 其中一个客户端发送消息 互相发送 那么话不多说，放码过来： 码云：传送门，GitHub：传送门 服务端：server.c #include <stdio....
linux：网络编程之TCP
最新发布
T66656的博客
08-29 1337
B/S模型是一种网络架构模式，其中用户通过网页浏览器（如Chrome、Firefox等）来访问和使用服务器上的应用程序或数据。
linux平台上的TCP并发服务--多线程版本
Ga526424的博客
05-11 706
联调服务器和客户端，服务器每收到一个连接就新建一个子进程，在子进程中接收客户端的服务时间请求，根据所请求的时间进行延时，然后终止子进程。如：客户端请求服务10s，则服务器的子进程运行10s，然后结束。其中，为服务器的IP地址，为服务器的端口号，为服务时间要求。用于管理线程池，包括线程数组、任务队列、队头、队尾、队列中任务数量以及互斥锁和条件变量。，该函数在一个循环中等待任务队列中的任务，处理任务，然后继续等待。函数将客户端请求的服务时间发送给服务器。
Linux c编程之TCP通信
szkbsgy的专栏
12-03 1110
TCP（Transmission Control Protocol），由RFC 793定义，中文名为传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。 TCP是常用的网络传输协议之一，该协议是面向连接、可靠传输的字节流协议。在Linux C网络程序中广泛使用，如http/https、ftp等。 TCP通信分为客户端和服务端，传输数据前需要客户端向服务端发起建立连接，数据传输完成后，双方可以断开连接。
在C中使用Socket实现多线程异步TCP消息发送
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
08-17 2531
详细介绍了在C中使用Socket实现多线程异步TCP消息发送。欢迎点赞收藏。谢谢
QT_TCP.rar_C/S服务器_QT TCP_linux 网络_tcp linux QT_tcp s/c
07-14
QT_TCP.rar 文件包含了一个基于Linux平台的C/S（客户机/服务器）架构的TCP网络通信程序，使用了QT库来实现TCP套接字的交互。QT是一个跨平台的应用开发框架，特别适合于创建图形用户界面应用程序，同时也支持非GUI...
linux_多线程无阻塞socket.zip_linux_linux socket tcp_tablep1c_tcp+线程_tc
09-15
在Linux系统中，Socket编程是实现网络通信的基础，特别是在多线程环境中，它能提供高效的数据传输和并发处理能力。本教程将深入探讨Linux下的多线程无阻塞Socket编程，涉及TCP协议、线程管理和TCP连接池技术，旨在...
基于Linux的TCP多线程网络聊天室源码（内含Makefile）
10-25
在本项目中，我们探索的是一个基于Linux操作系统利用C语言实现的TCP多线程网络聊天室。这个项目的核心目标是让学习者深入了解TCP协议以及如何在Linux环境下利用多线程技术构建一个网络通信应用。下面将详细介绍其中...
c/c++：基于TCP协议实现Linux下客户端与服务器之间的通信，实现多线程、多进程服务器代码模板
陈宸的博客
12-21 1785
目录 TCP协议Linux多进程服务器代码模板： TCP协议Linux多线程服务器代码模板： 客户端代码模板： TCP协议Linux多进程服务器代码模板： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include...
linux C TCP/UDP客户端服务端的相互实时通信
06-29
linux C TCP/UDP客户端服务端的相互实时通信 在ubuntu 下测试通过
Linux socket 搭建TCP服务器（C语言）
qq_44876700的博客
02-28 2247
​ TCP 是一种传输层协议，可以提供可靠的数据传输服务。它是面向连接的，具有可靠性、流量控制、拥塞控制以及双工通信的特点。​ TCP 是一种传输层协议，可以提供可靠的数据传输服务。​ 在TCP服务器中用到了六个函数socketbindlistenacceptrecv和send。​ 实现TCP服务器仅需将上述六个函数按顺序运用即可。我们还利用多线程的方法实现了一定量的并发，但是依旧存在一些问题，它是一线程一请求的形式，如果请求过多，服务器将会资源耗尽，因此无法实现大的并发量。
C语言 TCP并发服务器
ma_de_hao_mei_le的博客
03-25 461
友链 gcc 1.c -o 1 -lpthread gcc 2.c -o 2 -lpthread 服务端 // 、、使用内存映射可以拷贝文件 /* 对原始文件进行内存映射 创建一个新文件 把新文件的数据拷贝映射到内存中 通过内存拷贝将第一个文件的内存映射区拷贝到第二个文件的内存映射区 释放资源 */ // 匿名映射，不需要文件实体来进行内存映射 // 只能用于有血缘关系的进程间通信 #include <sys/mman.h> #include <pthread.h> #includ
【C语言】实现linux下的基于C语言的一个简单的TCP客/服 端的通信
赖东东_的博客
06-20 3848
struct sockaddr_in serv_addr； 这个结构体是定义在头文件中 大家可以从代码中看出 sockaddr_in 这个结构体中的成员就是ip地址簇、端口号、ip地址。
Linux C/C++ 开发（学习笔记十一 ）：TCP服务器（并发网络网络编程 一请求一线程）
菊头蝙蝠的博客
03-14 2289
Linux C/C++ 开发（学习笔记十一 ）：TCP服务器（并发网络网络编程 一请求一线程）一、TCP服务器（一请求一线程） 的原理二、完整代码三、测试四、补充 一、TCP服务器（一请求一线程） 的原理 通过sockfd绑定(bind)和监听(listen)，每过来一个客户端就接受(accept)，并创建一个clientfd，每个clientfd，占据一个线程。 每个线程执行 接受(recv)并printf的任务。 具体的监听过程 二、完整代码 #include<sys/socket.h>
Linux C TCP服务器demo
Gnwaye的博客
08-27 288
TCP服务器demo 基于TCP服务器， fork多进程并发服务器 #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <sys/signal.h> #
linux下 socket tcp Server c语言编写（分别实现单进程，多进程，多线程）
wejack的专栏
09-28 1933
linux下socket tcp server c语言编写单进程、多进程、多线程三种实现
网络聊天室（TCP，多线程传输）实现
XITMan的博客
09-04 637
server.c #include<stdio.h> #include<stdlib.h> #include<string.h> #include<unistd.h> #include<sys/socket.h> #include<netinet/in.h> #include<pthread.h> #include<arpa/inet.h> #define MAX_BUF 50 #define NAME 2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值