TCP/IP网络编程 多线程服务器端的实现

信号量

信号量与互斥量类似，只是互斥量是用锁来控制线程访问而信号量是用二进制0，1来完成控制线程顺序。sem_post信号量加1，sem_wait信号量减1，当信号量为0时，sem_wait就会阻断，因此通过这样让信号量加1减1就能控制线程的执行顺序了。

注释：mac上测试信号量函数返回-1失败，以后还是Linux上整吧，也许这些接口已经过时了…

  1. #include 
  2.  
  3. int sem_init(sem_t *sem, int pshared, unsigned int value);//创建信号量 
  4.  
  5. int sem_destroy(sem_t *sem);//销毁信号量 
  6.  
  7. int sem_post(sem_t *sem);//信号量加1 
  8.  
  9. int sem_wait(sem_t *sem);//信号量减1，为0时阻塞

实例代码：线程A从用户输入得到值后存入全局变量num，此时线程B将取走该值并累加。该过程共进行5次，完成后输出总和并退出程序。

  1. #include 
  2.  
  3. #include 
  4.  
  5. #include 
  6.  
  7. void * read(void * arg); 
  8.  
  9. void * accu(void * arg); 
  10.  
  11. static sem_t sem_one; 
  12.  
  13. static sem_t sem_two; 
  14.  
  15. static int num; 
  16.  
  17. int main(int argc, char *argv[]) 
  18.  
  19. { 
  20.  
  21. pthread_t id_t1, id_t2; 
  22.  
  23. sem_init(&sem_one, 0, 0); 
  24.  
  25. sem_init(&sem_two, 0, 1); 
  26.  
  27. pthread_create(&id_t1, NULL, read, NULL); 
  28.  
  29. pthread_create(&id_t2, NULL, accu, NULL); 
  30.  
  31. pthread_join(id_t1, NULL); 
  32.  
  33. pthread_join(id_t2, NULL); 
  34.  
  35. sem_destroy(&sem_one); 
  36.  
  37. sem_destroy(&sem_two); 
  38.  
  39. return 0; 
  40.  
  41. } 
  42.  
  43. void * read(void * arg) 
  44.  
  45. { 
  46.  
  47. int i; 
  48.  
  49. for (i = 0; i < 5; i++) { 
  50.  
  51. fputs("Input num: ", stdout); 
  52.  
  53. sem_wait(&sem_two); 
  54.  
  55. scanf("%d", &num); 
  56.  
  57. sem_post(&sem_one); 
  58.  
  59. } 
  60.  
  61. return NULL; 
  62.  
  63. } 
  64.  
  65. void * accu(void * arg) 
  66.  
  67. { 
  68.  
  69. int sum = 0 , i; 
  70.  
  71. for (i = 0; i < 5; i++) { 
  72.  
  73. sem_wait(&sem_one); 
  74.  
  75. sum+= num; 
  76.  
  77. sem_post(&sem_two); 
  78.  
  79. } 
  80.  
  81. printf("Result: %d \n", sum); 
  82.  
  83. return NULL; 
  84.  
  85. }

补充：线程的销毁，线程创建后并不是其入口函数返回后就会自动销毁，需要手动销毁，不然线程创建的内存空间将一直存在。一般手动销毁有如下两种方式：1，调用pthread_join函数，其返回后同时销毁线程 ，是一个阻断函数，服务端一般不用它销毁，因为服务端主线程不宜阻断，还要实时监听客服端连接。2，调用pthread_detach函数，不会阻塞，线程返回自动销毁线程，不过要注意调用它后不能再调用pthread_join函数，它与pthread_join主要区别就是一个是阻塞函数，一个不阻塞。

多线程并发服务端的实现

使用多线程实现了一个简单的聊天程序，并对临界区(clnt_cnt,clnt_socks)进行加锁访问.

服务端：

  1. // 
  2.  
  3. // main.cpp 
  4.  
  5. // hello_server 
  6.  
  7. // 
  8.  
  9. // Created by app05 on 15-10-22. 
  10.  
  11. // Copyright (c) 2015年 app05. All rights reserved. 
  12.  
  13. //临界区是：clnt_cnt和clnt_socks访问处 
  14.  
  15. #include 
  16.  
  17. #include 
  18.  
  19. #include 
  20.  
  21. #include 
  22.  
  23. #include 
  24.  
  25. #include 
  26.  
  27. #include 
  28.  
  29. #define BUF_SIZE 100 
  30.  
  31. #define MAX_CLNT 256 
  32.  
  33. void * handle_clnt(void * arg); 
  34.  
  35. void send_msg(char *msg, int len); 
  36.  
  37. void error_handling(char * msg); 
  38.  
  39. int clnt_cnt = 0; 
  40.  
  41. int clnt_socks[MAX_CLNT]; 
  42.  
  43. pthread_mutex_t mutx; 
  44.  
  45. int main(int argc, char *argv[]) 
  46.  
  47. { 
  48.  
  49. int serv_sock, clnt_sock; 
  50.  
  51. struct sockaddr_in serv_adr, clnt_adr; 
  52.  
  53. socklen_t clnt_adr_sz; 
  54.  
  55. pthread_t t_id; 
  56.  
  57. if (argc != 2) { 
  58.  
  59. printf("Usage : %s \n", argv[0]); 
  60.  
  61. exit(1); 
  62.  
  63. } 
  64.  
  65. //创建互斥量 
  66.  
  67. pthread_mutex_init(&mutx, NULL); 
  68.  
  69. serv_sock = socket(PF_INET, SOCK_STREAM, 0); 
  70.  
  71. memset(&serv_adr, 0, sizeof(serv_adr)); 
  72.  
  73. serv_adr.sin_family = AF_INET; 
  74.  
  75. serv_adr.sin_addr.s_addr = htonl(INADDR_ANY); 
  76.  
  77. serv_adr.sin_port = htons(atoi(argv[1])); 
  78.  
  79. if(bind(serv_sock, (struct sockaddr *) &serv_adr, sizeof(serv_adr)) == -1) 
  80.  
  81. error_handling("bind() error"); 
  82.  
  83. if(listen(serv_sock, 5) == -1) 
  84.  
  85. error_handling("listen() error"); 
  86.  
  87. while (1) 
  88.  
  89. { 
  90.  
  91. clnt_adr_sz = sizeof(clnt_adr); 
  92.  
  93. clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz); //阻断，监听客服端连接请求 
  94.  
  95. //临界区 
  96.  
  97. pthread_mutex_lock(&mutx); //加锁 
  98.  
  99. clnt_socks[clnt_cnt++] = clnt_sock; //新连接的客服端保存到clnt_socks数组里 
  100.  
  101. pthread_mutex_unlock(&mutx); //释放锁 
  102.  
  103. //创建线程 
  104.  
  105. pthread_create(&t_id, NULL, handle_clnt, (void*) &clnt_sock); 
  106.  
  107. pthread_detach(t_id); //销毁线程，线程return后自动调用销毁，不阻断 
  108.  
  109. printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr)); 
  110.  
  111. } 
  112.  
  113. close(serv_sock); 
  114.  
  115. return 0; 
  116.  
  117. } 
  118.  
  119. //线程执行 
  120.  
  121. void * handle_clnt(void * arg) 
  122.  
  123. { 
  124.  
  125. int clnt_sock = *((int *)arg); 
  126.  
  127. int str_len = 0, i; 
  128.  
  129. char msg[BUF_SIZE]; 
  130.  
  131. while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0) 
  132.  
  133. send_msg(msg, str_len); 
  134.  
  135. //从数组中移除当前客服端 
  136.  
  137. pthread_mutex_lock(&mutx); 
  138.  
  139. for (i = 0; i < clnt_cnt; i++) 
  140.  
  141. { 
  142.  
  143. if (clnt_sock == clnt_socks[i]) 
  144.  
  145. { 
  146.  
  147. while (i++ < clnt_cnt - 1) 
  148.  
  149. clnt_socks[i] = clnt_socks[i + 1]; 
  150.  
  151. break; 
  152.  
  153. } 
  154.  
  155. } 
  156.  
  157. clnt_cnt--; 
  158.  
  159. pthread_mutex_unlock(&mutx); 
  160.  
  161. close(clnt_sock); 
  162.  
  163. return NULL; 
  164.  
  165. } 
  166.  
  167. //向所有连接的客服端发送消息 
  168.  
  169. void send_msg(char * msg, int len) 
  170.  
  171. { 
  172.  
  173. int i; 
  174.  
  175. pthread_mutex_lock(&mutx); 
  176.  
  177. for (i = 0; i < clnt_cnt; i++) 
  178.  
  179. write(clnt_socks[i], msg, len); 
  180.  
  181. pthread_mutex_unlock(&mutx); 
  182.  
  183. } 
  184.  
  185. void error_handling(char *message) 
  186.  
  187. { 
  188.  
  189. fputs(message, stderr); 
  190.  
  191. fputc('\n', stderr); 
  192.  
  193. exit(1); 
  194.  
  195. } 


共4页: 上一页1234下一页

相关内容