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

编程语言 2023-10-04 18:01:57 阅读次数: 0

多进程并发服务器

设计流程

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

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;
		}
	}

}

猜你喜欢

转载自blog.csdn.net/m0_72847002/article/details/132589964
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
OOP第二次作业
java web 乱码问题
android 禁止scrollview 因控件变化自动滚动到底的方法
mysql服务解压版的安装(5.7)
centos7 nginx+tomcat配置https 安装免费SSL Let’s Encrypt
使用Mosquitto遗嘱机制实现感知客户端上下线功能的方法
面向对象之------多态与多态性
开发Teams Tabs应用程序
C# 希尔排序
第2章 Jupyter Notebooks
每日归档
更多
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022