9.3tcp多进程并发模板和多线程并发模板

最新推荐文章于 2024-08-08 17:37:05 发布
最新推荐文章于 2024-08-08 17:37:05 发布
阅读量847 收藏
点赞数
分类专栏： linux学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a312024054/article/details/47395315
版权

多进程并发模板

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

#define MAX_LINE 80
#define SERV_PORT 8000

void do_sig_child(int num)  //通过子进程结束时发送给父进程信号回收子进程
{
    while (waitpid(0, 0, 0) > 0)//阻塞回收
        ;   
}

int main(void)
{
    int servfd, clifd;
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddrlen;
    int i, len;
    pid_t pid;
    char buf[MAX_LINE];
    char str[MAX_LINE];
    struct sigaction act;

    act.sa_handler = do_sig_child;//设置信号捕捉函数
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, NULL);

    servfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));//初始化服务器地址信息
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    Bind(servfd, (struct sockaddr *)&servaddr, sizeof(servaddr));//绑定
    Listen(servfd, 20);

    printf("Accepting ...\n");

    while (1) {
        cliaddrlen = sizeof(cliaddr);
        clifd = Accept(servfd, (struct sockaddr *)&cliaddr, &cliaddrlen);

        pid = fork();
        if (pid == 0) { //子进程
            Close(servfd);
            printf("Receving : %s, PORT: %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), ntohs(cliaddr.sin_port));

            while (1) {
                len = Read(clifd, buf, sizeof(buf));
                if (len == 0) { //为0时说明客户端关闭连接，跳出循环
                    printf("one client exit\n");
                    break;
                }

                for (i = 0; i < len; i++)
                    buf[i] = toupper(buf[i]);
                Write(clifd, buf, len);
            }

            Close(clifd);
            return 0;//结束子进程
        } else if (pid > 0) {
            Close(clifd);
        } else {
            perr_exit("fock error");
        }
    }

    Close(servfd);
    return 0;
}

多线程并发模板

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "wrap.h"
#include <strings.h>
#include <pthread.h>
#include <string.h>
#include <ctype.h>

#define SERV_PORT 8000
#define MAX_LINE 80
int clifd;  //设置全局变量，一遍让线程可以访问

void *th_fun(void *arg)
{
    int clientfd = clifd;
    int i, len;
    char buf[MAX_LINE];

    while (1) {

        len = Read(clientfd, buf, sizeof(buf));
        if (len == 0) {
            printf("one client exit\n");
            break;
        }   
        for (i = 0; i < len; i++)
            buf[i] = toupper(buf[i]);
        Write(clientfd, buf, len);
    }
    Close(clientfd);
    return NULL;
}

int main(void)
{
    int servfd;
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddrlen;
    char str[MAX_LINE];
    pthread_t tid;
    pthread_attr_t attr;
    int n;

    pthread_attr_init(&attr);//设置线程分离属性
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    servfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));//初始化地址信息
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    servaddr.sin_addr.s_addr = htons(INADDR_ANY);

    Bind(servfd, (struct sockaddr *)&servaddr, sizeof(servaddr));//绑定

    Listen(servfd, 20);
    printf("Accepting ...\n");
    while (1) {
        cliaddrlen = sizeof(cliaddr);
        clifd = Accept(servfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
        printf("Rece: %s, PORT: %d\n", inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), ntohs(cliaddr.sin_port));

        n = pthread_create(&tid, &attr, th_fun, NULL);//创建线程
        if (n != 0)//出错处理
            fprintf(stderr, "pthread_create:%s\n", strerror(n));

    }
    Close(servfd);

    return 0;
}

wrap函数出错处理

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

void perr_exit(const char *str)
{
    perror(str);
    exit(1);
}

int Socket(int family, int type, int protocol)
{
    int n;
    if ((n = socket(family, type, protocol)) < 0)  
        perr_exit("socket error");
    return n;
}

void Bind(int sockfd, const struct sockaddr *sa, socklen_t salen)
{
    if (bind(sockfd, sa, salen) < 0)
        perr_exit("bind error");
}

void Listen(int sockfd, int backlog)
{
    if (listen(sockfd, backlog) < 0)
        perr_exit("listen error");
}

int Accept(int sockfd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n;
    while ((n = accept(sockfd, sa, salenptr)) < 0) {
        if ((errno == ECONNABORTED) || (errno == EINTR))//如果是被信号打断的，重新读取
            ;
        else
            perr_exit("accept error");
    }
    return n;
}

int Read(int fd, void *ptr, int  nbytes)
{
    int  n;
    while ((n = read(fd, ptr, nbytes)) == -1) {
        if (errno == EINTR)//如果是被信号打断的，重新读取
            ;
        else
            return -1;
    }
    return n;
}

int  Write(int fd, const void *ptr, int nbytes)
{
    int n;
    while ((n = write(fd, ptr, nbytes)) == -1) {
        if (errno == EINTR)//如果是被信号打断的，重新写
            ;
        else
            return -1;
    }
    return n;
}

void Close(int fd)
{
    if (close(fd) == -1)
        perr_exit("close error");
}

wrap.h

#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>

#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *str);

int Accept(int sockfd, struct sockaddr *sa, socklen_t  *salenptr);

int Socket(int family, int type, int protocol);

void Bind(int sockfd, const struct sockaddr *sa, socklen_t salen);

void Listen(int sockfd, int backlog);

int Read(int fd, void *ptr, int nbytes);

int Write(int fd, const void *ptr, int nbytes);

void Close(int fd);

#endif

客户端

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <strings.h>
#include "wrap.h"

#define SERV_PORT 8000
#define SERV_IP "192.168.188.133"   
#define MAX_LINE 80

int main(void)
{
    int servfd;
    struct sockaddr_in servaddr;
    int len;
    char buf[MAX_LINE];

//  while (1) {
    servfd = Socket(AF_INET, SOCK_STREAM, 0); 

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, SERV_IP, &servaddr.sin_addr);

    connect(servfd, (struct sockaddr *)&servaddr, sizeof(servaddr));


    while (1) {
        len = Read(STDIN_FILENO, buf, sizeof(buf));

        Write(servfd, buf, len);
//      Write(servfd, "hello", 5);
        len = Read(servfd, buf, sizeof(buf));
        Write(STDOUT_FILENO, buf, len);
    }

    return 0;
}
小小初行者
关注
专栏目录
浅谈多线程并发以及一些简单的demo
qq_23665305的博客
04-29 660
差不多做了一段时间的java开发了，然后其实项目上高并发用到的并不多。就只有自己来学习一下了，网上搜了下资料，然后自己总结了一下。下面开始正题。 现目前许多项目都会涉及到高并发的问题，先来说下线程和进程。 进程：操作系统中正在运行的程序。 线程：是进程中的一个执行流程； 用一句话来说，解决高并发问题，就是解决多线程对某个资源的有序访问和修改。避免脏读，幻读等。通常来说数据库也可以解决这类...
Linux常见的进程间通信
wtl666_6的博客
01-26 7146
Linux常见的进程间通信
system V IPC进程间通信机制一网打尽
小杰312的博客
04-27 6370
system V IPC进程间通信机制一网打尽
Linux必知必会,答应我拿下这些Linux必备技能
小杰312的博客
04-24 1万+
Linux必知必会,这些Linux知识你确定掌握清楚了吗
Linux进程间通信详解(五) —— 信号量及函数
码农爱学习的博客
05-25 579
信号量的概念 信号量，或称信号灯，其原理是一种数据操作锁的概念，本身不具备数据交换的功能，它负责协调各个进程，保证保证两个或多个关键代码段不被并发调用，确保公共资源的合理使用。信号量分为单值和多值两种。 在信号的实际应用中，是不能只定义一个信号量的，而只能定义一个信号量集，其中包含一组信号量，同一信号量集中的信号量使用同一个引用ID，这样的设置是为了多个资源或同步操作的需要。每个信号量集都有一个与之对应的结构，其中记录了信号量集的各种信息，该结构定义为： struct semid_ds { str
【Linux的线程篇章 - 线程、进程、多线程、多进程等知识】
最新发布
m0_69455439的博客
08-08 975
Linux学习笔记017 -- Linux的线程篇章 - 线程、进程、多线程、多进程等知识
Linux多线程服务端编程：使用muduo C++网络库
08-17
《Linux多线程服务端编程：使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。...
开涛高可用高并发-亿级流量核心技术
03-22
19.2 数据和模板动态化 381 19.3 多版本机制 381 19.4 异常问题 382 20 使用OpenResty开发Web服务 383 20.1 架构 383 20.2 单DB架构 384 20.2.1 DB+Cache/数据库读写分离架构 384 20.2.2 OpenResty+Local Redis+...
TCP、UDP、TCP三次握手与四次挥手、TCP如何保证可靠传输、TCP异常分析、拆包和粘包等
loytuls的博客
03-20 1223
关于计算机网络的面试官最爱问的问题：TCP、UDP、TCP三次握手与四次挥手、TCP如何保证可靠传输、TCP异常分析、拆包和粘包等（必问问题）
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
python-定时器_协程_greenlet模块_gevent模块_单线程的套接字并发_io模型
qq_31455841的博客
09-19 558
线程协程 1. 线程池和进程池的shutdown # 主线程等待所有任务执行完成 import time from concurrent.futures import ThreadPoolExecutor pool = ThreadPoolExecutor(3) def task(name): print('%s 开始'%name) time.sleep(1) print('%s 结束'%name) if __name__ == '__main__': for
Linux第七章相关代码
XuJiaLiang的博客
04-28 208
胜利老师yyds 书上有些有错误，这里代码都已调好。 7-1 #include <unistd.h> #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> #include<stdlib.h> #include<stdio.h> int main(void) { int fdl,fd2,fd3,nbytes; int flags=O_CREAT|O_TRUNC|O_
操作系统实验时遇到的问题
sx_zy的博客
12-31 1138
操作系统实验时遇到的问题： Readme: 头文件的问题，由于不足造成隐式声明不兼容的问题 这里给出一般需要的头文件： #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #includ
嵌入式Linux网络编程·笔记2·系统调用篇（一）
weixin_45596239的博客
03-04 413
一、Create 1、头文件：#include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> 2、函数原型：int create(const char *pathname, mode_t mode); 3、函数内形参：创建文件名（路径）、文件权限（RWX， 0655当前用户RW...
linux下gcc参数的使用以及编译过程
a312024054的专栏
07-20 4593
gcc的使用-v / --v / --version 查看gcc版本号-I目录 指定头文件目录，注意-I和目录之间没有空格-c 只编译，生成.o文件，不进行链接-g 包含调试信息-On n=1~3 编译优化，n越大优化的越多-Wall 提示更多告警信息（严格编译)-D<DEF> 编译时定义宏，注意-D和<DEF>之间没有空格-E 生成预处理文件，一般是.i文件,(展开头文件，替换宏
C#多线程编程详解
多线程能够实现并发执行，提高效率，如同时处理用户输入、网络请求等。然而，多线程也可能带来资源竞争、性能下降等问题，需要合理管理和同步。 9.2 .NET对多线程的支持 .NET框架提供了丰富的支持来处理多线程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值