Linux实现多进/线程并发服务端Socket通信

最新推荐文章于 2022-12-14 16:30:57 发布
最新推荐文章于 2022-12-14 16:30:57 发布
阅读量543 收藏 8
点赞数
分类专栏： Linux系统 网络编程 文章标签： socket 多进程 多线程 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43290168/article/details/117307103
版权

Linux实现多进/线程并发服务端Socket通信

多进程并发服务端

程序流程

在这里插入图片描述
服务端实现流程：

  1. 创建套接字，绑定地址结构，设置监听上限等。
  2. 循环调用accept函数接收客户端请求并创建子进程。
  3. 子进程中关闭套接字（不进行其他操作），父进程中完成服务端与客户端数据通信。
  4. 在父进程中注册信号捕捉函数，等待子进程结束并进行回收，避免僵尸进程的出现。
  5. 调用read函数循环读取客户端数据，完成大小写转换，调用write函数写回数据至客户端。

服务端程序

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <signal.h>
#include "wrap.h"
using namespace std;
//定义服务端端口号
#define SERVER_PORT  9527

void catch_child(int signum)
{
    while((waitpid(0,NULL,WNOHANG))>0);
    return ;
}
int main (int argc ,char*argv[])
{
    int lfd=0;//用于监听的套接字
    int cfd=0;//用于通信的套接字

    pid_t pid;
    int ret ;
    char buf[BUFSIZ];

    //创建套接字
    lfd=Socket(AF_INET,SOCK_STREAM,0);
    //创建地址结构
    struct sockaddr_in server_addr,client_addr;
    socklen_t client_addr_len;
    //初始化
    //memset(&server_addr,0,sizeof(server_addr));//将地址结构清零
    bzero(&server_addr,sizeof(server_addr));

    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SERVER_PORT);
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    //绑定地址结构
    Bind(lfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    //设置监听
    Listen(lfd,128);
   
    client_addr_len=sizeof(client_addr);
    // 循环接收客户端请求
    while(1)
    {
        cfd=Accept(lfd,(struct sockaddr*)&client_addr,&client_addr_len);
        //创建子进程
        pid=fork();
        if (pid<0)//检查创建进程是否成功
        {
           sys_err("fork error"); 
        }
        else if(pid==0)//子进程
        {
            close(lfd);//关闭监听套接字
            break;
        }
        //父进程
        else{
            struct sigaction act;
            act.sa_handler=catch_child;
            sigemptyset(&act.sa_mask);
            act.sa_flags=0;
            //注册新号捕捉函数
            ret=sigaction(SIGCHLD,&act,NULL);
            if(ret!=0)
            {
                sys_err("sigaction error");
            }
            //关闭套接字
            close(cfd);
            continue;
        }
    }
        if(pid==0)
        {
            //循环读取客户端数据信息
            for(;;)
            {
                ret=Read(cfd,buf,sizeof(buf));
                //输出到屏幕
                write(STDOUT_FILENO,buf,ret);
                if(ret==0)
                {
                    //读完数据后关闭套接字
                    close(cfd);
                    exit(1);
                }
                //完成大小写转换
                for (int i=0;i<ret;i++)
                {
                    buf[i]=toupper(buf[i]);
                }
                //数据写回到buf
                write(cfd,buf,ret);     
            }
        }
    return 0;
}

客户端程序

这里与之前的客户端程序一样

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <ctype.h>
#include <arpa/inet.h>
#include "wrap.h"
using namespace std;

//定义一个端口号(服务端)
#define SERVER_PORT  9527
//#define BUFSIZ _IO_BUFSIZ

// void sys_err(const char *str)
// {
//     perror(str);
//     exit(1);
// }
int main (int argc,char *argv[])
{
    int ret=0; 
    int c_fd=0;//创建用于通信的文件描述符
    char buf[BUFSIZ];
    struct sockaddr_in server_addr;//创建服务端地址结构体
    //初始化成员
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SERVER_PORT);
    //server_addr.sin_addr.s_addr=htonl(INADDR_ANY);//任意有效ip

    //将点分十进制的ip地址转化为用于网络传输的二进制数值格式
    inet_pton(AF_INET,"127.0.0.1",&(server_addr.sin_addr));
    c_fd=Socket(AF_INET,SOCK_STREAM,0);//创建套接字
    if(c_fd==-1)
    {
        sys_err("socket error");
    }
    //客户端与服务端建立连接
    ret=connect(c_fd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    if(ret==-1)
    {
         sys_err("connect error");
    }
    //循环写入数据
    while(1)
    {
        fgets(buf,sizeof(buf),stdin);
        write(c_fd,buf,strlen(buf));
        ret=read(c_fd,buf,sizeof(buf));
        write(STDOUT_FILENO,buf,ret);
    }
    //关闭套接字
    close(c_fd);
    return 0;
}

运行结果

服务端：
在这里插入图片描述
客户端：在这里插入图片描述
在这里插入图片描述
客户端中止进程（Ctrl+C）：
如果子进程不进行回收，会出现僵尸进程
在这里插入图片描述
在这里插入图片描述

多线程并发服务端

程序流程

在这里插入图片描述
服务端实现流程：

  1. 创建套接字，绑定地址结构，设置监听上限等。
  2. 循环调用accept函数接收客户端请求并创建子线程。
  3. 子线程回调函数用于完成客户端与服务端的数据通信，调用read函数循环读取客户端数据，完成大小写转换，调用write函数写回数据至客户端。
  4. 在主线程中完成线程分离（调用pthread_detach函数），自动回收子线程。

服务端程序

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <signal.h>
#include <pthread.h>
#include "wrap.h"
using namespace std;
//定义服务端端口号
#define SERVER_PORT  9527

struct s_info {                     //定义一个结构体, 将地址结构跟cfd捆绑
    struct sockaddr_in client_addr;
    int cfd;
};

//子线程回调函数
void *do_work(void *arg)
{
    int n,i;
    struct s_info *ts = (struct s_info*)arg;
    char buf[BUFSIZ];
    char str[INET_ADDRSTRLEN];      //#define INET_ADDRSTRLEN 16  可用"[+d"查看

    while (1) {
        n = Read(ts->cfd, buf, BUFSIZ);                     //读客户端
        if (n == 0) {
            printf("the client %d closed...\n", ts->cfd);
            break;                                              //跳出循环,关闭cfd
        }
        printf("received from %s at PORT %d\n",
                inet_ntop(AF_INET, &(*ts).client_addr.sin_addr, str, sizeof(str)),
                ntohs((*ts).client_addr.sin_port));             //打印客户端信息(IP/PORT)

        for (i = 0; i < n; i++) 
            buf[i] = toupper(buf[i]);                           //小写-->大写

        Write(STDOUT_FILENO, buf, n);                           //写出至屏幕
        Write(ts->cfd, buf, n);                                 //回写给客户端
    }
    Close(ts->cfd);

    return (void *)0;   //pthread_exit()  结束子线程
}
int main (int argc ,char*argv[])
{
    int lfd=0;//用于监听的套接字
    int cfd=0;//用于通信的套接字

    pid_t pid;
    int ret,i=0 ;
    char buf[BUFSIZ];

    //创建套接字
    lfd=Socket(AF_INET,SOCK_STREAM,0);
    //创建地址结构
    struct sockaddr_in server_addr,client_addr;
    socklen_t client_addr_len;

    pthread_t tid;
    //根据最大线程数创建结构体数组
    struct s_info ts[256];  

    //初始化
    //memset(&server_addr,0,sizeof(server_addr));//将地址结构清零
    bzero(&server_addr,sizeof(server_addr));

    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SERVER_PORT);
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    //绑定地址结构
    Bind(lfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    //设置监听
    Listen(lfd,128);
   
    client_addr_len=sizeof(client_addr);
    // 循环接收客户端请求
    while(1)
    {
        cfd=Accept(lfd,(struct sockaddr*)&client_addr,&client_addr_len);

        ts[i].client_addr = client_addr;
        ts[i].cfd = cfd;

        /* 达到线程最大数时，pthread_create出错处理, 增加服务器稳定性 */
        pthread_create(&tid, NULL, do_work, (void*)&ts[i]);
        //子线程分离,防止僵线程产生.
        pthread_detach(tid);                                                    
        i++;
    }
    return 0;
}

客户端程序

同多进程客户端

运行结果

服务端：
在这里插入图片描述
客户端：
在这里插入图片描述
在这里插入图片描述

附录（错误处理函数封装）

//wrap.cpp
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include "wrap.h"
void sys_err(const char *str)
{
    perror(str);
    exit(1);
}
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
	int n;
again:
	if ((n = accept(fd, sa, salenptr)) < 0) {
		if ((errno == ECONNABORTED) || (errno == EINTR))
			goto again;
		else
			sys_err("accept error");
	}
	return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;
	if ((n = bind(fd, sa, salen)) < 0)
		sys_err("bind error");
    return n;
}
// int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
// {
//     int n;
//     n = connect(fd, sa, salen);
// 	if (n < 0) {
// 		perr_exit("connect error");
//     }
//     return n;
// }

int Listen(int fd, int backlog)
{
    int n;
	if ((n = listen(fd, backlog)) < 0)
		sys_err("listen error");
    return n;
}
int Socket(int domain, int type, int protocol)
{
	int n;
	if ((n = socket(domain, type, protocol)) < 0)
		sys_err("socket error");
	return n;
}
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
	ssize_t n;
again:
	if ( (n = read(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

// ssize_t Write(int fd, const void *ptr, size_t nbytes)
// {
// 	ssize_t n;
// again:
// 	if ((n = write(fd, ptr, nbytes)) == -1) {
// 		if (errno == EINTR)
// 			goto again;
// 		else
// 			return -1;
// 	}
// 	return n;
// }

// int Close(int fd)
// {
//     int n;
// 	if ((n = close(fd)) == -1)
// 		perr_exit("close error");

//     return n;
// }

// /*参三: 应该读取的字节数*/                          //socket 4096  readn(cfd, buf, 4096)   nleft = 4096-1500
// ssize_t Readn(int fd, void *vptr, size_t n)
// {
// 	size_t  nleft;              //usigned int 剩余未读取的字节数
// 	ssize_t nread;              //int 实际读到的字节数
// 	char   *ptr;

// 	ptr = vptr;
// 	nleft = n;                  //n 未读取字节数

// 	while (nleft > 0) {
// 		if ((nread = read(fd, ptr, nleft)) < 0) {
// 			if (errno == EINTR)
// 				nread = 0;
// 			else
// 				return -1;
// 		} else if (nread == 0)
// 			break;

// 		nleft -= nread;   //nleft = nleft - nread 
// 		ptr += nread;
// 	}
// 	return n - nleft;
// }

// ssize_t Writen(int fd, const void *vptr, size_t n)
// {
// 	size_t nleft;
// 	ssize_t nwritten;
// 	const char *ptr;

// 	ptr = vptr;
// 	nleft = n;
// 	while (nleft > 0) {
// 		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
// 			if (nwritten < 0 && errno == EINTR)
// 				nwritten = 0;
// 			else
// 				return -1;
// 		}
// 		nleft -= nwritten;
// 		ptr += nwritten;
// 	}
// 	return n;
// }

// static ssize_t my_read(int fd, char *ptr)
// {
// 	static int read_cnt;
// 	static char *read_ptr;
// 	static char read_buf[100];

// 	if (read_cnt <= 0) {
// again:
// 		if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {   //"hello\n"
// 			if (errno == EINTR)
// 				goto again;
// 			return -1;
// 		} else if (read_cnt == 0)
// 			return 0;

// 		read_ptr = read_buf;
// 	}
// 	read_cnt--;
// 	*ptr = *read_ptr++;

// 	return 1;
// }

// /*readline --- fgets*/    
// //传出参数 vptr
// ssize_t Readline(int fd, void *vptr, size_t maxlen)
// {
// 	ssize_t n, rc;
// 	char    c, *ptr;
// 	ptr = vptr;

// 	for (n = 1; n < maxlen; n++) {
// 		if ((rc = my_read(fd, &c)) == 1) {   //ptr[] = hello\n
// 			*ptr++ = c;
// 			if (c == '\n')
// 				break;
// 		} else if (rc == 0) {
// 			*ptr = 0;
// 			return n-1;
// 		} else
// 			return -1;
// 	}
// 	*ptr = 0;

// 	return n;
// }

//wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_

void sys_err(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
// int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int domain, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
// ssize_t Write(int fd, const void *ptr, size_t nbytes);
// int Close(int fd);
// ssize_t Readn(int fd, void *vptr, size_t n);
// ssize_t Writen(int fd, const void *vptr, size_t n);
// ssize_t my_read(int fd, char *ptr);
// ssize_t Readline(int fd, void *vptr, size_t maxlen);
#endif
暗月li
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从0实现基于Linux socket聊天室-多线程服务器模型(一)
嵌入式技术开发
07-01 708
多线程、多进程模型主要特点是每个网络请求由一个进程/线程处理，线程内部使用阻塞式系统调用，在线程的职能划分上，可以由一个单独的线程处理accept连接，其余线程处理具体的网络请求（收包，处理，发包）；单线进程循环原理就是主进程没和客户端通信，客户端都要先连接服务器，服务器接受一个客户端连接后从客户端读取数据，然后处理并将处理的结果返还给客户端，然后再接受下一个客户端的连接请求。1、线程内部还是阻塞的，举个极端的例子，如果一个线程在handle的业务逻辑中sleep了，这个线程也就挂住了。
Linux网络编程 之 TCP 多线程的服务器和客户端同时收发数据
11-22 6699
具体的相关TCP 的资料我这里就不多说，我会在末尾贴出来。 直接上源码吧，里面有一些跟本题无关的我已经屏弊掉了，里面的注释也很清楚，大家只要自己看一下就应该知道了。 1、服务器端代码(Server.c) #include #include #include #include #include #include #include #include #include
Linux网络编程（二）——socket通信基础
Alkaid2000的博客
12-14 1913
Linux下的socket编程以及TCP的详解。
Linux下基于socket多线程并发通信的实现
yffhhffv的博客
11-13 478
Linux下基于socket多线程并发通信的实现
linux多线程socket通信程序设计,Linux下基于socket多线程并发通信的实现
weixin_33541245的博客
05-08 198
//程序存在bug，会不断占用内存直到死机//是malloc函数的问题/**************************************************** 文件名：pthread_server.c* 文件描述：创建子线程来接收客户端的数据***************************************************/#include #include ...
Linux + socket多线程并发服务端+ 聊天室
07-27
本项目“Linux + socket多线程并发服务端+ 聊天室”旨在教授如何利用Linux环境下的socket编程实现一个支持多线程并发的聊天室服务端。下面我们将深入探讨相关知识点。 首先，让我们了解**Socket**。Socket是进程间...
python socket threading 多线程服务端
12-21
总结来说，这个Python Socket多线程服务端示例展示了如何通过Socket进行文件传输，并利用多线程同时处理多个客户端的上传请求，提高了服务端的并发处理能力。通过学习这个示例，开发者可以进一步理解Python的网络...
Windows下基于socket多线程并发通信的实现
04-07
本文介绍了在Windows 操作系统下基于TCP/IP 协议Socket 套接口的通信机制以及多线程编程知识与技巧，并给出多线程方式实现多用户与服务端(C/S)并发通信模型的详细算法，最后展现了用C++编写的多用户与服务器通信的...
Linux下基于socket多线程并发通信的实现 (2).pdf
09-06
在Linux操作系统中，基于Socket实现多线程并发通信是一种常见的网络编程方式，尤其适用于构建高效、高并发的服务端应用程序。Socket接口是TCP/IP协议栈的一部分，它为应用程序提供了跨网络进行数据交换的能力，抽象...
基于Linux的多线程火车售票系统设计源码
最新发布
04-18
系统采用了Java、C和Python编程语言，实现了具有上下两层架构（app、device）的Linux服务端，包括多线程技术、并发处理、socket通信、环形缓冲区等技术。同时设计了两层的通信协议，顶层协议用于打包解析命令和消息...
【转载】Linux 实现多线程服务端Socket通信（线程共享套接字无法正常通信问题分析与解决）
hs_lxy的博客
12-22 524
目录 程序流程 程序实例  值得注意的地方 运行结果 与多进程服务器处理连接类似，本例的目的是在主线程中创建多个子线程来处理连接请求。 程序流程 1. 创建基本的套接字，并绑定地址信息、设置监听； 2. 创建一个线程函数，用于子线程中进行客户端与服务端的数据通信； 3. 循环accept来接收连接请求，每接收一个连接请求，就创建一个子线程； 4. 将子线程detach()，使子线程在...
linux C实现socket通信（单线程和多线程的实现）
lj779323436的博客
06-05 3503
socket通信是网络编程的基础，对于其概念的解释以及知识点的介绍网上都写的很详细了，这里不再啰嗦，这里主要是基于linux实现简单的客户端服务器端通信，功能为从客户端输入一行字符（可包含空格），服务器收到后进行显示并将收到的字符串再发送给客户端，并且服务器端可以一直对客户端的连接进行监听（这里先只实现一个客户端的连接，后面引入多线程，让多个客户端可以同时连接服务器端）。 服务器端流程为创建socket->绑定->监听->连接->通信->关闭socket 代码里有详细注释，
linux 网络编程:使用两线程实现socket同时收发数据
Biao
09-26 1万+
工作中最近有使用到socket 向客户端同时发送和接收数据，因为是嵌入式linux设备，且要求只能同时一个客户端连接该端口。考虑到节省系统资源，只创建了两个线程分别实现服务端的收发数据。下面直接上代码，该代码为在PC机上程序，已作详细注释。 server.c #include #include #include #include #include #include #include #incl...
linux多线程socket通信程序,Linux下基于soCket多线程并发通信实现.pdf
weixin_32325225的博客
05-01 165
网络与通信 《微计算机信息》( 管控一体化)2009 年第25 卷第 5-3 期文章编号:1008-0570(2009)05-3-0070-03Linux 下基于socket 多线程并发通信的实现The accomplishment of multi-pthread Communication Ba...
linux循环接收socket,Linux下socket编程（实现回声客户端功能（修改版while（）循环接收））...
weixin_35750953的博客
05-15 165
#include #define BUF_SIZE 100int main(){//创建套接字int serv_sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);//将套接字和ip、端口绑定struct sockaddr_in serv_addr;memset(&serv_addr,0,sizeof(serv_addr));//每个字节都用0填充s...
linux 多线程客户端服务端通信,[转载]多线程实现服务器和客户端、客户端和客户端通信；需要代码，留言...
weixin_42347600的博客
05-11 351
一、实验名称动手打造自己的IM二、实验目的1本次实验旨在锻炼大家的Socket编程能力，以日常生活中广泛使用的IM软件为背景，培养大家对于网络编程的兴趣。2、通过本次实验，培养linux环境下网络编程能力，使得我们对网络应用层的网络应用软件有了一个深入的理解，这对网络课程的学习起到了很好的实践作用。三、实验内容及步骤实验内容：本作业要求同学们完成一个简陋的IM的客户端和服务器端，实现一些最基本和...
用C语言编写Linux系统下支持高并发的websocket服务端程序
baidu_39146182的博客
08-03 4071
    本人使用c语言编写的websocket服务端程序，默认支持1024条并发，可修改参数轻易支持更高并发，80%以上源码写有注释，阅读本篇博文可帮助websocket小白快速入门websocket编程，积分有多的朋友可去下载完整源码支持一下原创。 下面是主文件完整代码：        代码符合c99标准可在linux环境下使用gcc编译通过，其他编译器请自行测试              ...
高并发的socket的高性能设计
热门推荐
情义唯真，友谊方长存
03-26 2万+
高性能的高并发socket设计 本文是从网络上搜集的几篇较好的文章： 主要转载自： http://blog.csdn.net/qifengzou/article/details/23912267 http://www.cricode.com/3499.html 来自"祁峰"的CSDN博客： 高性能数据传输系统的框架设计 1 引言    随着互联网和物联网的高速发
linux服务器并发sokect,Linux下基于socket多线程并发通信的实现
weixin_33610601的博客
04-30 115
/**************************************************** 文件名：pthread_server.c* 文件描述：创建子线程来接收客户端的数据***************************************************/#include #include #include #include #include #inc...
Socket聊天系统设计：网络通信与多线程实现
服务端设计则关注如何处理来自多个客户端的并发请求，这通常需要利用多线程技术。在多线程设计中，服务端和客户端都需要管理多个并发连接，确保信息的及时传递。 代码实现阶段，分别展示了服务端和客户端的代码结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值