Linux 多线程并发Socket服务端的实现( 11 ) -【Linux通信架构系列】

偏执的太偏执、 2024-03-22 21:15 99阅读 0赞

## 系列文章目录 ##

[C++技能系列][C]  
[Linux通信架构系列][Linux]  
[C++高性能优化编程系列][C 1]  
[深入理解软件架构设计系列][Link 1]  
[高级C++并发线程编程][C 2]  
[设计模式系列][Link 2]

**期待你的关注哦！！！**  
![在这里插入图片描述][b09b24d6d28c4d7f9557fdf640801a16.png_pic_left]

***`现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。`***  
***`Now everything is for the future of dream weaving wings, let the dream fly in reality.`***

#### Linux 多线程并发Socket服务端的实现 ####

*  系列文章目录
 *  一、Linux线程的介绍
 *  二、多线程并发服务端的实现

## 一、Linux线程的介绍 ##

*  **`（1）头文件`**  
    \#include < pthread.h >
 *  **`（2）创建线函数`**  
    int `pthread_create`( pthread\_t \* restrict `thread`, const pthread\_attr\_t \* restrict `attr`, void\* (\* `start_routine`)(void \*), void \* restrict `arg` );  
    成功时返回0，失败时返回其他值。  
    – **thread : 保存新创建线程ID的变量地址。区分不同线程；**  
    – **attr : 用于传递线程属性的参数，传递NULL时，创建默认属性的线程；**  
    – **start\_routine : 相当于线程main函数的、在单独执行流中执行的函数的地址值（函数指针）；**  
    – **arg : 通过第三个函数传递调用函数时包含传递参数信息的变量地址值。**  
    **调用pthread\_join函数 - 与之聚合（等待线程终止）**  
    int `pthread_join`(pthread\_t thread, void \*\* status);  
    成功时返回0，失败时返回其他值。  
    **– thread : 该参数值ID的线程终止后才会从该函数返回；**  
    **– status : 保存线程的main函数返回值的指针变量地址值。**  
    **调用pthread\_detach函数 - 与之分离**  
    int `pthread_detach`(pthread\_t thread);  
    成功时返回0，失败时返回其他值。  
    **– thread 终止的同时需要销毁的线程ID。**
 *  **`（3）互斥量`**  
    int `pthread_mutex_init`(pthread\_mutex\_t \* mutex, const pthread\_mutex \* attr);  
    int `pthread_mutex_destroy`(pthread\_mutex\_t \* mutex);  
    成功时返回0，失败时返回其他值。  
    **– mutex 创建互斥量时传递保存互斥量的变量地址值，销毁时传递需要销毁的互斥量的地址值；**  
    **– attr 传递即将创建的互斥量属性，没有特别需要指定的属性时传递NULL。**  
    int `pthread_mutex_lock`(pthred\_mutex\_t \* mutex);  
    int `pthread_mutex_unlock`(pthread\_mutex\_t \* mutex);  
    成功时返回0，失败时返回其他值。  
    互斥量锁。
 *  **`（4）信号量`**  
    \#include< semaphore.h >  
    int `sem_init`(sem\_t \* sem, int pshared, unsigned int value);  
    int `sem_destroy`(sem\_t \* sem);  
    成功时返回0，失败时返回其他值。  
    **– sem :创建信号时传递保存信号量的变量的地址值，销毁时传递需要销毁的信号量变量地址值；**  
    **– pshared :传递其他值时，创建可由多个进程共享的信号量；传递0时，创建只允许1个进程内部使用的信号量；**  
    **– value :指定新创建信号量的初始值。**  
    int `sem_post`(sem\_t \* sem);  
    int `sem_wait`(sem\_t \* sem);  
    成功时返回0，失败时返回其他值。  
    **– sem :传递保存信号量读取值的变量地址值，传递给sem\_post时信号量增1，传递给sem\_wait时信号量减1,信号值不能小于0，因此，在信号量为0的时候调用sem\_wait函数时，线程进入阻塞状态。**

## 二、多线程并发服务端的实现 ##

如下介绍是多个客户端之间可以交换信息的简单的聊天程序（不是严格的商业代码）。

**chart\_server.c**

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<unistd.h>
    #include<arpa/inet.h>
    #include<sys/socket.h>
    #include<fcntl.h>
    #include<errno.h>
    #include<pthread.h>
    #define BUF_SIZE 100
    #define MAX_CLNT 256
    
    void * handle_clnt(void * arg);
    void send_msg(char * msg, int len);
    void error_handling(char * msg);
    int clnt_cnt = 0;
    int clnt_socks[MAX_CLNT];
    pthread_mutex_t mutex;
    
    int main(int argc, char *argv[])
    {
        
    	//用来管理接入的客户端套接字的变量和数组。访问这两个变量的代码将构成临界区
    	int serv_sock, clnt_sock; 
    	struct sockaddr_in serv_adr, clnt_adr;
    	int clnt_adr_sz;
    	pthread_t t_id;
    	if(argc != 2){
        
    		printf("Usage : %s <port> \n", argv[0]);
    		exit(1);
    	}
    
    	pthread_mutex_init(&mutex, NULL);
    	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    	
    	memset(&serv_adr, 0, sizeof(serv_adr));
    	serv_adr.sin_family = AF_INET;
    	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    	serv_adr.sin_port = htons(atoi(argv[1]));
    
    	if(bind(serv_sock, (struct sockaddr *) &serv_adr, sizeof(serv_adr)) == -1)
    		error_handling("bind() error");
    	if(listen(serv_sock, 5) == -1)
    		error_handling("listen() error");
    	
    	while(1)
    	{
        
    		clnt_adr_sz = sizeof(clnt_adr);
    		clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
    
    		pthread_mutex_lock(&mutex);
    		//每当有新的连接时，将相关信息写入变量clnt_cnt和clnt_socks
    		clnt_socks[clnt_cnt++] = clnt_sock;
    		pthread_mutex_unlock(&mutex);
    
    		//创建线程向新连入的客户端提供服务
    		pthread_create(&t_id, NULL, handle_clnt, (void*)&clnt_sock);
    		//调用pthread_detach函数从内存中完全销毁已终止的线程
    		pthread_detach(t_id);
    		printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
    	}
    	close(serv_sock);
    	return 0;
    }
    
    void * handle_clnt(void * arg)
    {
        
    	int clnt_sock = *((int*)arg);
    	int str_len = 0, i;
    	char msg[BUF_SIZE];
    
    	while((str_len = read(clnt_sock, msg, sizeof(msg))) != 0)
    		send_msg(msg, str_len);
    	
    	pthread_mutex_lock(&mutex);
    	for(i = 0; i < clnt_cnt; i++) //remove disconnected client
    	{
        
    		if(clnt_sock == clnt_socks[i])
    		{
        
    			while(i++ < clnt_cnt - 1)
    				clnt_socks[i] = clnt_socks[i + 1];
    			break;
    		}
    	}
    	clnt_cnt--;
    	pthread_mutex_unlock(&mutex);
    	close(clnt_sock);
    	return NULL;
    }
    
    //该函数负责向所有客户端发送消息
    void send_msg(char *msg, int len) // send to all
    {
        
    	int i;
    	pthread_mutex_lock(&mutex);
    	for(i = 0; i < clnt_cnt; i++)
    		write(clnt_socks[i], msg, len);
    	pthread_mutex_unlock(&mutex);
    }
    
    void error_handling(char *msg)
    {
        
    	fputs(msg, stderr);
    	fputc('\n', stderr);
    	exit(1);
    }

**chat\_clnt.c**

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<unistd.h>
    #include<arpa/inet.h>
    #include<sys/socket.h>
    #include<fcntl.h>
    #include<errno.h>
    #include<pthread.h>
    #define BUF_SIZE 100
    #define NAME_SIZE 20
    
    void * send_msg(void *arg);
    void * recv_msg(void *arg);
    void error_handling(char *msg);
    
    char name[NAME_SIZE] = "[DEFAULT]";
    char msg[BUF_SIZE];
    
    int main(int argc, char *argv[])
    {
        
    	int sock;
    	struct sockaddr_in serv_addr;
    	pthread_t snd_thread, rcv_thread;
    	void *thread_return;
    	if(argc != 4){
        
    		printf("Usage : %s <IP> <port> <name> \n", argv[0]);
    		exit(1);
    	}
    	
    	sprintf(name, "[%s]", argv[3]);
    	sock = socket(PF_INET, SOCK_STREAM, 0);
    
    	memset(&serv_addr, 0, sizeof(serv_addr));
    	serv_addr.sin_family = AF_INET;
    	serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    	serv_addr.sin_port = htons(atoi(argv[2]));
    
    	if(connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
    		error_handling("connect() error");
    	
    	pthread_create(&snd_thread, NULL, send_msg, (void *)&sock);
    	pthread_create(&rcv_thread, NULL, recv_msg, (void *)&sock);
    	pthread_join(snd_thread, &thread_return);
    	pthread_join(rcv_thread, &thread_return);
    	close(sock);
    	return 0;
    }
    
    void *send_msg(void *arg) //send thread main
    {
        
    	int sock = *((int *)arg);
    	char name_msg[NAME_SIZE + BUF_SIZE];
    	while(1)
    	{
        
    		fgets(msg, BUF_SIZE, stdin);
    		if(!strcmp(msg, "q\n") || !strcmp(msg, "Q\n"))
    		{
        
    			close(sock);
    			exit(0);
    		}
    		sprintf(name_msg, "%s %s", name, msg);
    		write(sock, name_msg, strlen(name_msg));
    	}
    	return NULL;
    }
    
    void *recv_msg(void * arg) //read thread main
    {
        
    	int sock = *((int *) arg);
    	char name_msg[NAME_SIZE + BUF_SIZE];
    	int str_len;
    	while(1)
    	{
        
    		str_len = read(sock, name_msg, NAME_SIZE + BUF_SIZE - 1);
    		if(str_len == -1)
    			return (void *) - 1;
    		name_msg[str_len] = 0;
    		fputs(name_msg, stdout);
    	}
    	return NULL;
    }
    
    void error_handling(char *msg)
    {
        
    	fputs(msg, stderr);
    	fputc('\n', stderr);
    	exit(1);
    }

运行结果如下：  
![在这里插入图片描述][0cfed24c28b94fdea1fe63c1b581e067.jpeg_pic_center]

图1\_1 聊天室运行结果

[C]: https://blog.csdn.net/weixin_30197685/category_12344315.html
[Linux]: https://blog.csdn.net/weixin_30197685/category_12353489.html
[C 1]: https://blog.csdn.net/weixin_30197685/category_12332626.html
[Link 1]: https://blog.csdn.net/weixin_30197685/category_12332639.html
[C 2]: https://blog.csdn.net/weixin_30197685/category_12332628.html
[Link 2]: https://blog.csdn.net/weixin_30197685/category_12387201.html
[b09b24d6d28c4d7f9557fdf640801a16.png_pic_left]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/439e034ddb2b42d289f51af4f92fd57f.png
[0cfed24c28b94fdea1fe63c1b581e067.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/75475baeacd543ca9397e4d587260be0.png