TCP服务器并发编程

字数统计: 1.4k字   |   阅读时长≈ 7分

TCP服务器并发编程

服务端三种实现方式：循环模式、多进程、多线程

  • TCP服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define USE_THREADS 1 // 1 多线程方式， 0 用多进程方式
//#define SERV_IP_ADDR "192.168.1.100"
#define SERV_PORT 9999

#if USE_THREADS
#include <pthread.h>
#else
#include <sys/wait.h>
#include <signal.h>
void sig_child_handle(int signo);
#endif

void cli_data_handle(void *argc);

int main (int argv, char **argc)
{
    int fd;
    struct sockaddr_in sin = {0};

    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    // 优化3：运行绑定地址快速重用
    int b_reuse = 1;
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(SERV_PORT); // 端口号转成网络字节序
    
	// 优化1：让服务器能绑定在任意的ip上
	sin.sin_addr.s_addr = htonl(INADDR_ANY); // INADDR_ANY其实等于-1，这样整形所有的位都是1
    
    /* 绑定套接字 */
    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)  
    {
        perror("bind");
        exit(-1);
    }

    /* 把主动套接字变成被动套接字 */
    if (listen(fd, 5) < 0)
    {
        perror("listen");
        exit(-1);
    }

    /* 阻塞等待客户端链接请求 */
    int newfd;
    struct sockaddr_in cin;
    socklen_t clen = sizeof(cin);

#if USE_THREADS   // 多线程方式运行服务端
    printf("sever is run threads\n");
    while(1)
    {
        newfd = accept(fd, (struct sockaddr *)&cin, &clen); // 得到新连接的客户端信息
        if (newfd < 0) 
        {
            perror("accept");
            exit(-1);
        }

        char ipv4_addr[16];
        if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
        {
            perror("inet_ntop");
            exit(-1);
        }
        printf("new client is connectde : %s:%d\n", ipv4_addr, htons(sin.sin_port));

        // 优化2：没连接一个客户端创建一个线程专门处理这个客户端的读写
        pthread_t tid;
        pthread_create(&tid, NULL, (void *)cli_data_handle, (void *)&newfd);
    }
    
    close (fd);

    return 0;
}
#else	// 多进程方式运行服务端
    printf("sever is run process\n");
    pid_t pid = -1;

    // 设置进程在接收到SIGCHID信号时的处理函数，子进程结束会发SIGCHID信号给父进程
    signal(SIGCHLD, sig_child_handle);

    while (1)
    {
        newfd = accept(fd, (struct sockaddr *)&cin, &clen); // 得到新连接的客户端信息
        if (newfd < 0) 
        {
            perror("accept");
            exit(-1);
        }

        pid = fork(); // 创建一个子进程

        if (pid < 0)
        {
            perror("fork");
            exit(-1);
        }
        else if (pid == 0) // 子进程
        {
            close(fd); // 不需要就关闭父进程继承过来的
            char ipv4_addr[16];
            if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
            {
                perror("inet_ntop");
                exit(-1);
            }
            printf("new client is connectde : %s:%d\n", ipv4_addr, ntohs(sin.sin_port));

            cli_data_handle((void *)&newfd);
            exit(1); // 对方断开了结束子进程
        }
        else // 父进程
        {
            close(newfd); // 父进程用不到为了不浪费资源就关闭
            /* 父进程继续下次循环等待accept（）返回 */
        }
    }
}

/* 进程接收到SIGCHID信号的处理函数 */
void sig_child_handle(int signo)
{
    if (SIGCHLD == signo)
    {
        waitpid(-1, NULL, WNOHANG); // 非阻塞查询是否有子进程结束需要回收
    }
} 
#endif

/* 与客户端的接收、发送处理函数 */
void cli_data_handle(void *argc)
{
    int cfd = *(int *)argc;
    
    /* 读写套接字 */
    #define BUF_SIZE 1024
    int ret = -1;
    char buf[BUF_SIZE];

    while (1) 
    {
        bzero (buf, BUF_SIZE); // 数组清零
        do 
        {
            ret = read (cfd, buf, BUF_SIZE-1);
        } while (ret < 0 && EINTR == errno); // EINTR读文件被中断，继续读文件

        if (ret < 0) 
        {
            perror ("read");
            exit (-1);
        }

        if (0 == ret) //对方已经关闭，文件读完了到文件末尾了
        { 
            break;
        }
        printf ("Receive data : %s\n", buf);

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
            printf("Client is exiting!\n");
            break;
        }

        if (write(cfd, buf, strlen(buf) + 1) < 0) //发送数据到客户端
        {
            perror ("write");
            exit (-1);
        }
    }
	// 如果是线程处理函数，函数退出后就会自动删除该线程
    close (cfd);
}

  • TCP客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

void usage(char *s)
{
    printf("\n%s serv_ip serv_port", s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
    int fd;
    short port;
    struct sockaddr_in sin = {0};
    
    if (argc < 3)
    {
        usage(argv[0]);
        exit(1);
    }

    port = atoi(argv[2]);
    if (port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(port); // 端口号转成网络字节序
    sin.sin_addr.s_addr = inet_addr(argv[1]); // 将点斜式ip转成整形ip，内部自动转成网络字节序

    /* 连接服务器 */
    if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(-1);
     }
    printf("conect sever success\n");

    /* 读写套接字 */
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];

    while (1)
    {
        bzero (buf, BUF_SIZE); // 数组清零
        if (fgets(buf, BUF_SIZE, stdin) < 0)
        {
                continue;
        }
        write(fd, buf, strlen(buf));

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
                printf("Client is exiting!\n");
                break;
        }
    }

    close (fd);

    return 0;
}

运行结果：

  • 使用多进程方式时，每连接一个客户端，父进程就会创建一个tcp_server子进程
  • 使用多线程方式时，每连接一个客户端，进程就会创建一个新的线程

进程状态：S代表进程阻塞，l代表该进程存在多线程，s代表该进程拥有子进程，+代表是前台进程

源码地址： http://gitea.880755.xyz/private/TCP_Dome.git

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发