TCP->多进程服务器->多进程服务器->线程池

最新推荐文章于 2023-07-16 10:36:48 发布
最新推荐文章于 2023-07-16 10:36:48 发布
阅读量969 收藏
点赞数
分类专栏： Linux知识库 linux程序 文章标签： tcp 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Quinn0918/article/details/76439050
版权

TCP流式套接字

makefile

.PHONY:all
all : tcp_client tcp_server

tcp_client : tcp_client.c
    gcc - o $@ $^ -static
tcp_server:tcp_server.c
    gcc - o $@ $^

.PHONY:clean
clean :
    rm - f tcp_server tcp_client

tcp_server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
static usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n",proc);
}

int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    printf("sock: %d\n",sock);

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);//192.168.X.X

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock, 10) < 0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

//./tcp_server 192.18.X.X 8080
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client, &len);
        if(new_sock < 0)
        {
            perror("accept");
            continue;
        }

        printf("get new client [%s:%d]\n",\

                inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));


        //read ->write
        while(1)
        {
            char buf[1024];
            ssize_t s = read(new_sock, buf, sizeof(buf)-1);
            if(s > 0)
            {


                buf[s] = 0;
                printf("client# %s\n",buf);

                write(new_sock, buf, strlen(buf));

            }else if(s == 0)
            {

                printf("client close!!\n");

                break;
            }else
            {


                perror("read");
                break;
            }
        }
        close(new_sock);
    }
    return 0;
}

tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

static void usage(const char *proc)
{   
    printf("Usage: %s [server_ip] [server_port]\n",proc);
}

//./tcp_client server_ip server_port

int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }


    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connect");
        return 3;
    }

    char buf[1024];
    while(1)
    {
        printf("Please Enter#");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf) - 1);
        if(s > 0)
        {
            buf[s-1]= 0;
            write(sock, buf, strlen(buf));
            ssize_t _s = read(sock, buf, sizeof(buf)-1);
            if(_s > 0)
            {

                buf[_s] = 0;

                printf("server echo# %s\n",buf);
            }
        }

    }

    close(sock);

    return 0;
}

多进程服务器

makefile

.PHONY:all
all:tcp_client tcp_server

tcp_client:tcp_client.c
    gcc -o $@ $^ -static
tcp_server:tcp_server.c
    gcc -o $@ $^

.PHONY:clean
clean:
    rm -f tcp_server tcp_client

tcp_server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
static usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n",proc);
}

int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    printf("sock: %d\n",sock);

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);//192.168.X.X

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock, 10) < 0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

//./tcp_server 192.18.X.X 8080
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client, &len);
        if(new_sock < 0)
        {
            perror("accept");
            continue;
        }

        printf("get new client [%s:%d]\n",\


                inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        pid_t id = fork();
        if(id < 0)
        {
            perror("fork");
            close(new_sock);

        }
        else if(id == 0)//child
        {
            close(listen_sock);
            if(fork()> 0 )//child->father
            {
                exit(0);
            }
            //read ->write
            while(1)
            {

            char buf[1024];
            ssize_t s = read(new_sock, buf, sizeof(buf)-1);
            if(s > 0)
            {
                buf[s] = 0;
                printf("client# %s\n",buf);
                write(new_sock, buf, strlen(buf));

            }
            else if(s == 0)
            {
                printf("client close!!\n");
                break;
            }
            else
            {
                perror("read");
            }
        }
            close(new_sock);
            exit(0);
        }

        else//father
        {
            close(new_sock);
            waitpid(id,NULL,0);
        }
    }
    return 0;
}

tcp_client.c

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

static void usage(const char *proc)
{   
    printf("Usage: %s [server_ip] [server_port]\n",proc);
}

//./tcp_client server_ip server_port

int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }


    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connect");
        return 3;

    }

    char buf[1024];
    while(1)
    {
        printf("Please Enter#");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf) - 1);
        if(s > 0)
        {
            buf[s-1]= 0;
            write(sock, buf, strlen(buf));
            ssize_t _s = read(sock, buf, sizeof(buf)-1);
            if(_s > 0)
            {

                buf[_s] = 0;

                printf("server echo# %s\n",buf);
            }
        }

    }

    close(sock);

    return 0;
}

多线程服务器

makefile


.PHONY:all
all:tcp_client tcp_server

tcp_client:tcp_client.c
    gcc -o $@ $^ -static
tcp_server:tcp_server.c
    gcc -o $@ $^ -lpthread

.PHONY:clean
clean:
    rm -f tcp_server tcp_client

tcp_server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
static usage(const char *proc)
{
    printf("Usage: %s [local_ip] [local_port]\n",proc);
}

int startup(const char *ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    printf("sock: %d\n",sock);

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);//192.168.X.X

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock, 10) < 0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}

void *request(void *arg)
{
    int new_sock = (int)arg;
    while(1)
    {
         char buf[1024];
         ssize_t s = read(new_sock, buf, sizeof(buf)-1);
         if(s > 0)
         {

             buf[s] = 0;
             printf("client# %s\n",buf);
             write(new_sock, buf, strlen(buf));       
         }
         else if(s == 0)
         {
             printf("client close!!\n");
             break;

         }
         else
         {
             perror("read");
             break;
         }
    }
    close(new_sock);
    return (void*)0;


}



//./tcp_server 192.18.X.X 8080
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int listen_sock = startup(argv[1], atoi(argv[2]));

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock,(struct sockaddr*)&client, &len);
        if(new_sock < 0)
        {
            perror("accept");
            continue;
        }

        printf("get new client [%s:%d]\n",\


                inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        pthread_t id;
        pthread_create(&id,NULL,request,(void*)new_sock);
        pthread_detach(id);
    }
    return 0;
}

tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

static void usage(const char *proc)
{   
    printf("Usage: %s [server_ip] [server_port]\n",proc);
}

//./tcp_client server_ip server_port

int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }


    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connect");
        return 3;

    }

    char buf[1024];
    while(1)
    {
        printf("Please Enter#");
        fflush(stdout);
        ssize_t s = read(0, buf, sizeof(buf) - 1);
        if(s > 0)
        {
            buf[s-1]= 0;
            write(sock, buf, strlen(buf));
            ssize_t _s = read(sock, buf, sizeof(buf)-1);
            if(_s > 0)
            {

                buf[_s] = 0;

                printf("server echo# %s\n",buf);
            }
        }

    }

    close(sock);

    return 0;
}

进程池和线程池

进程池和线程池相似，所以这里我们以进程池为例进行介绍。如没有特殊声明，下面对进程池的描述也适用于线程池。

进程池是由服务器预先创建的一组子进程，这些子进程的数目在 3~10 个之间（当然这只是典型情况）。线程池中的线程数量应该和 CPU 数量差不多。

进程池中的所有子进程都运行着相同的代码，并具有相同的属性，比如优先级、 PGID 等。

当有新的任务来到时，主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程，选择一个已经存在的子进程的代价显得小得多。至于主进程选择哪个子进程来为新任务服务，则有两种方法：

1）主进程使用某种算法来主动选择子进程。最简单、最常用的算法是随机算法和 Round Robin （轮流算法）。

2）主进程和所有子进程通过一个共享的工作队列来同步，子进程都睡眠在该工作队列上。当有新的任务到来时，主进程将任务添加到工作队列中。这将唤醒正在等待任务的子进程，不过只有一个子进程将获得新任务的“接管权”，它可以从工作队列中取出任务并执行之，而其他子进程将继续睡眠在工作队列上。

当选择好子进程后，主进程还需要使用某种通知机制来告诉目标子进程有新任务需要处理，并传递必要的数据。最简单的方式是，在父进程和子进程之间预先建立好一条管道，然后通过管道来实现所有的进程间通信。在父线程和子线程之间传递数据就要简单得多，因为我们可以把这些数据定义为全局，那么它们本身就是被所有线程共享的。

线程池主要用于：

1）需要大量的线程来完成任务，且完成任务的时间比较短。 比如WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大。但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2）对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。

3）接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。

Quinn0918
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程设计模式 进程详解
04-16
《JAVA多线程设计模式》PDF 下载 《Java线程 高清晰中文第二版》中文第二版(PDF) 前言 第一章 线程简介 Java术语 线程概述 为什么要使用线程？ 总结 第二章 Java线程API 通过Thread类创建线程 使用Runable接口...
【TCP/IP】多进程服务器的实现(进阶) - 进程的概念及fork函数
Tsang的博客
06-08 884
进程（Process）是计算机中程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
【TCP/IP】多进程服务器的实现(进阶) - 多进程服务器模型及代码实现
Tsang的博客
06-12 2744
经过前面的铺垫，我们已经具备实现并发服务器的基础了，接下来让我们尝试将之前的单任务回声服务器改装成多任务并发模式
多进程并发服务器
laugh哥的博客
11-28 733
最核心的就是：多进程实现客户端，然后把出错处理函数模块化
并发服务器 - 多进程服务器
weixin_45684629的博客
12-04 649
通过多进程服务器来实现并发服务器、客户端读写功能分割到进程
TCP/IP网络编程（3）——多进程服务器实现（fork函数复制socket问题）
drinkwaterwater的博客
05-05 551
本文记录实现多进程服务器的方法。另外，重点记录一下关于我遇到的fork函数复制socket时产生的问题和原因，以及如何解决。
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
3. 采用模拟 Proacto r的事件处理模式，利用线程池实现多线程机制，实现高并发通信，减少频繁创建和销毁线程带来的开销；（信号和互斥锁） 4. 主进程负责事件的读写，子线程负责业务逻辑——用有限状态机解析HTTP...
TCP/IP网络编程 第十章:多进程服务器端
最新发布
Reol99999的博客
07-16 1115
简要的介绍了一下多进程服务器
多进程服务器，多线程服务器
sakura0908的博客
03-19 275
/每次一个新的客户端连接上来，开启一条线程，接收 客户端的数据 25 pthread_create(,,routine,&newClientFd);//捕捉 SIGCHLD信号 执行 信号响应函数，在该函数中 回收子进程。//创建一个子进程，子进程负责接收每一个连接上来的客户端数据。//子进程退出的时候 ，会自动发出来一个SIGCHLD信号。while(1){ //接收 客户端的数据。else if(id >0) //父进程。if(id == 0) //子进程{//接收 客户端的数据。
fork多进程实现一个服务器与多个客户端通信
12-10
fork多进程实现一个服务器与多个客户端通信，中南大学某课内作业
多进程并发服务器设计
04-04
Linux环境下应用进程和Socket套接字设计并发服务器，完成多用户聊天应用程序，本文档给出了系统设计模型、进程通信接口。
一个只有两千行代码的多进程负载均衡的http服务器
06-28
this project is a http server based on linux epoll. it has load balance like nginx for each work process it is now just used for static html page. dynamic web page is not support. if you want to run it. you enter the stripling directory and run the configure script first and then you can use make command to compile the code. the executable file will be stored in bin directory. there is some config item you can change. if you do not want to use the default configuration, you should edit the config.txt before run the configure script.
并发服务器-多进程服务器详解
09-18
并发服务器-多进程服务器详解
多进程服务器端
weixin_53344209的博客
03-16 505
之前打下了理论基础，现在才是开始学习构建实际服务器的知识。 0.1 进程概念及应用 利用之前学习到的内容，我们可以构建按序向第一个客户端到第一百个客户端提供服务的服务器端。当然，第一个客户端不会抱怨服务器端，但如果每个客户端的平均服务时间为0.5秒，则第100个客户端会对服务器端产生相当大的不满。 并发服务器端的实现方法 即使有可能延长服务时间，也有必要改进服务器端，使其同时向所有发起请求的客户端提供服务，以提高平均满意度。而且网络程序中数据通信时间比CPU运算时间占比更大，因此，向多个客户端提供服务是一种
多进程服务器基础
qq_40026625的博客
07-25 105
1.只能处理但链接 监听 绑定 监听 接受连接请求 通信 只有一个进程，则就看成父进程 父进程连接后，可以fork 个子进程去通信，就可以实现一个多进程通信 多进程服务器的实现基础 1.共享： 读时共享，写时复制 文件描述符 内存映射区 父进程的变量，fork 后再子进程中也存在 两者的虚拟空间不同，但其对应的物理空间是同一个。即父子进程在逻辑上仍然是严格相互独立的两个进程，各自维护各自的参数，只是在物理上实现了读时共享，写时复制。 进程中的变量都在虚拟内存里面 内核只为新生成的.
Linux并发服务器编程之多进程并发服务器
年轻人，潜力无限！
12-21 8623
前面的话 服务器按处理方式可以分为迭代服务器和并发服务器两类。平常用C写的简单Socket客户端服务器通信，服务器每次只能处理一个客户的请求，它实现简单但效率很低，通常这种服务器被称为迭代服务器。 然而在实际应用中，不可能让一个服务器长时间地为一个客户服务，而需要其具有同时处理 多个客户请求的能力，这种同时可以处理多个客户请求的服务器称为并发服务器，其效率很 高却实现复杂。在实际应用中，并发服
Linux网络编程 - 多进程服务器端（1）
yunfan
01-07 1817
在我们对Linux下的socket编程有了一定的理解后，想要实现真正能够提供服务的服务器端，还有很多的事情需要做。本博文中主要介绍如何构建一个多进程的服务器端。
b_tcp->abort()
06-06
是的，b_tcp->abort()是用来中止当前连接的方法，它会立即关闭套接字并释放所有相关的资源，包括缓冲区和未完成的操作。调用abort()方法后，你需要重新创建一个新的QTcpSocket对象并进行连接。以下是abort()方法的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值