多线程和套接字

• ​​​​​​server.cpp(编译时需要链接pthread库)

  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <sys/socket.h>
  #include <arpa/inet.h>
  #include <string.h>
  #include <pthread.h>
  #include <sys/epoll.h>
  
  const int gNameMaxSize = 20;
  const int gMessageMaxSize = 1024;
  
  int g_clnt_socks[500] = {0};
  int g_clnt_size = 0;
  
  pthread_mutex_t g_mutex;
  
  void handlError(char* message) {
      fputs(message, stderr);
      fputc('\n', stderr);
      exit(1);
  }
  
  void* procMessage(void* p) {
      printf("procMessage clntSock  :%d\n", *(int*)p);
      int clntSock = *(int*)p;
  
      char name[gNameMaxSize] = {0};
      read(clntSock, name, sizeof(name));
      printf("name :%s\n", name);
  
      char message[gMessageMaxSize] = {0};
      while(true) {
          int len = read(clntSock, message, sizeof(message));
          if(0 >= len) {
              // close connect
              pthread_mutex_lock(&g_mutex);
              for(int i = 0; i < g_clnt_size; i++) {
                  if(g_clnt_socks[i] == clntSock) {
                      g_clnt_size--;
                      while(i < g_clnt_size) {
                          g_clnt_socks[i] = g_clnt_socks[i + 1];
                      }
                      printf("disconnect %s\n", name);
                      break;
                  }
              }
              pthread_mutex_unlock(&g_mutex);
          } else {
              write(clntSock, message, sizeof(message));
              printf("%s :%s", name, message);
              if(0 >= len) {
                  printf("%d fputs() error", clntSock);
                  continue;
              }
  
              memset(message, 0, sizeof(message));
          }
      }
  
      return NULL;
  }
  
  int main(int argc, char **argv) {
      pthread_mutex_init(&g_mutex, NULL);
  
      if (argc < 2) handlError("<port>");
      
      int sock = socket(PF_INET, SOCK_STREAM, 0);
      if(-1 == sock) handlError("socket() error");
  
      struct sockaddr_in adrSock;
      adrSock.sin_family = PF_INET;
      adrSock.sin_addr.s_addr = INADDR_ANY;
      adrSock.sin_port = htons(atoi(argv[1]));
  
      if(bind(sock, (struct sockaddr *)&adrSock, sizeof(adrSock))) {
          handlError("bind() error");
      }
  
      if(listen(sock, sizeof(g_clnt_socks))) handlError("listen() error");
  
      socklen_t lenSock = sizeof(adrSock);
      while(true) {;
          int sockClnt = accept(sock, (struct sockaddr *)&adrSock, &lenSock);
          if (-1 == sockClnt) {
              printf("accept() happen an error");
              continue;
          }
  
          pthread_mutex_lock(&g_mutex);
          g_clnt_socks[g_clnt_size++] = sockClnt;
          pthread_mutex_unlock(&g_mutex);
  
          pthread_t thd;
          pthread_create(&thd, NULL, procMessage, (void*)&sockClnt);
          pthread_detach(thd);
      }
  
      close(sock);
  
      pthread_mutex_destroy(&g_mutex);
      return 0;
  }

• client.cpp

  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <sys/socket.h>
  #include <arpa/inet.h>
  #include <string.h>
  
  #define MAX_BUFF_SIZE 1024
  
  void handlError(char* message) {
      fputs(message, stderr);
      fputc('\n', stderr);
      exit(1);
  }
  
  int main(int argc, char **argv) {
      if (argc < 4) handlError("<IP> <port> <name>");
      
      int sock = socket(PF_INET, SOCK_STREAM, 0);
      if(-1 == sock) handlError("socket() error");
  
      struct sockaddr_in sockAdr;
      memset(&sockAdr, 0, sizeof(sockAdr));
      sockAdr.sin_family = AF_INET;
      sockAdr.sin_addr.s_addr = inet_addr(argv[1]);;
      sockAdr.sin_port = htons(atoi(argv[3]));
  
      if(connect(sock, (struct sockaddr *)&sockAdr, sizeof(sockAdr))) {
         handlError("connect() error");
      }
  
      char name[strlen(argv[2]) + 1] = {0};
      memccpy(name, argv[2], 0, sizeof(argv[3]));
      printf("name :%s, argv[2] :%s\n", name, argv[2]);
  
      if( 0 >= write(sock, name, sizeof(name))) {
          handlError("write() error");
      }
  
      char message[MAX_BUFF_SIZE] = {0};
      socklen_t sockLen = sizeof(sockAdr);
      while (true) {
          fputs("input(Q to quit): ", stdout);
          // fputc('\n', stdout);
          fgets(message, sizeof(message) - 1, stdin);
  
          if(!strcmp(message, "Q\n")) {
              shutdown(sock, SHUT_WR);
              break;
          }
  
          if( 0 >= write(sock, message, sizeof(message))) {
              handlError("write() error");
          }
  
          memset(message, 0, sizeof(message));
  
          read(sock, message, sizeof(message));
          printf("recv :%s", message);
  
          memset(message, 0, sizeof(message));
      }
  
      close(sock);
  
      return 0;
  }

• 运行命令：./server 9091和./client 127.0.0.1 Lee 9091