Multithreaded high concurrency server: three problems

1. Whether the sub thread can close the listening file descriptor ?

2. Whether the main thread can close the communication file descriptor ?

3. Multiple child threads share cfd, What problems will happen ?

answer 1： You can't , Parent and child threads share file descriptors , If the child process closes the listening file descriptor , Second child thread Accept It's going to go wrong .Accept The first parameter to is the listener file descriptor .

answer 2： You can't , If the main thread closes the communication file descriptor , This will directly cause the server to fail to read , because Read The first parameter to is the communication file descriptor .

answer 3： If multiple clients are connected to the server at the same time , The communication file descriptor will be overwritten , Only the last file descriptor works , Only one client can communicate normally .

terms of settlement ： These sub threads are not sharing the same memory , Instead, share an array （ Divide the memory into arrays of appropriate size ）, This will not cause the file descriptor to be overwritten .

The specific code is as follows ：

// Multithreaded version of the server 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <pthread.h>
#include "wrap.h"

typedef struct info
{
	int cfd;   // if -1 Means available ,  Greater than 0 Indicates occupied 
	int idx;
	pthread_t thread;
	struct sockaddr_in client;
}INFO;

INFO thInfo[1024];

// Thread execution function 
void *thread_work(void *arg)
{
	INFO *p = (INFO *)arg;
	printf("idx==[%d]\n", p->idx);

	char sIP[16];
	memset(sIP, 0x00, sizeof(sIP));
	printf("new client:[%s][%d]\n", inet_ntop(AF_INET, &(p->client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(p->client.sin_port));

	int n;
	int cfd = p->cfd;
	struct sockaddr_in client;
	memcpy(&client, &(p->client), sizeof(client));
	
	char buf[1024];
	
	while(1)
	{
		memset(buf, 0x00, sizeof(buf));
		// Reading data 
		n = Read(cfd, buf, sizeof(buf));
		if(n<=0)
		{
			printf("read error or client closed, n==[%d]\n", n);
			Close(cfd);
			p->cfd =-1;  // Set to -1 Indicates that the location is available 
			pthread_exit(NULL);
		}
		
		for(int i=0; i<n; i++)
		{
			buf[i] = toupper(buf[i]);
		}
		// send data 
		Write(cfd, buf, n);
	}
}

void init_thInfo()
{
	int i = 0;
	for(i=0; i<1024; i++)
	{
		thInfo[i].cfd = -1;;
	}
}

int findIndex()
{
	int i;
	for(i=0; i<1024; i++)
	{
		if(thInfo[i].cfd==-1)
		{
			break;
		}
	}
	if(i==1024)
	{
		return -1;
	}
	
	return i;
}

int main()
{
	// establish socket
	int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	// Set up port multiplexing 
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
	
	// binding -- take lfd  and  IP PORT binding 
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
	
	// monitor 
	Listen(lfd, 128);
		
	// initialization 
	init_thInfo();
	
	int cfd;
	int ret;
	int idx;
	socklen_t len;
	pthread_t thread;
	struct sockaddr_in client;
	while(1)
	{
		len = sizeof(client);
		bzero(&client, sizeof(client));
		// Get a new connection 
		cfd = Accept(lfd, (struct sockaddr *)&client, &len);
		// Create a subprocess ,  Let the child process handle the connection --- Receiving data and sending data 
		
		// Find a free position in the array 
		idx = findIndex();
		if(idx==-1)
		{
			Close(cfd);
			continue;
		}
		
		// Assign a value to the member of the element in the free position 
		thInfo[idx].cfd = cfd;
		thInfo[idx].idx = idx;
		memcpy(&thInfo[idx].client, &client, sizeof(client));
		
		// Create child threads --- This sub thread completes the sending and receiving of data 
		ret = pthread_create(&thInfo[idx].thread, NULL, thread_work, &thInfo[idx]);
		if(ret!=0)
		{
			printf("create thread error:[%s]\n", strerror(ret));
			exit(-1);
		}
		
		// Set the child thread as the separation property 
		pthread_detach(thInfo[idx].thread);
	
	}
	
	Close(lfd);
	
	return 0;
	
}

Next, test with three clients at the same time ：