AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

服务端socket开发之多线程和gevent框架并发测试[python语言]

2017-11-08 1509
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

测试下多线程和gevent在socket服务端的小包表现能力，测试的方法不太严谨，

有点属于自娱自乐，要是有问题之处，请大家喷之 ！


每个连接都特意堵塞了0.5秒钟 ！

012011164.jpg


在大批量tcp测试下，threading的开销越来越大，所以造成了在并发数加大的情况下，出现threading崩溃的情况 ！  gevent是 libevent和协程的融合，一个线程里面都可以跑超多的协程！ 利用libevent做io堵塞的调度 ，gevent体系下，同一时间只有一个任务在运行 ！    



先来测试下多线程：   我们就不加线程池了

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
#!/usr/bin/env python
# -*- coding: utf- 8  -*-
#xiaorui.cc
import  sys
import  socket
import  time
import  threading
#xiaorui.cc
def threads(port):
     s = socket.socket()
     s.bind(( '0.0.0.0' , port))
     s.listen( 500 )
     while  True:
         cli, addr = s.accept()
         t = threading.Thread(target=handle_request, args=(cli, time.sleep))
         t.daemon = True
         t.start()
def handle_request(s, sleep):
     try :
         s.recv( 1024 )
         sleep( 0.5 )                                                                                                           
         s.send( '' 'http/ 1.0  200  OK
                   Hello World!  '' ')
         s.shutdown(socket.SHUT_WR)
         print  '.' ,
     except Exception, ex:
         print ex
     finally :
         sys.stdout.flush()
         s.close()
if  __name__ ==  '__main__' :
     threads( 4444 )


用threading跑socket，每个连接堵塞的时间是0.5

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
time ab -n  10000  -c  500  http: //127.0.0.1:4444/
This  is  ApacheBench, Version  2.3  <$Revision:  655654  $>
Copyright  1996  Adam Twiss, Zeus Technology Ltd, http: //www.zeustech.net/
Licensed to The Apache Software Foundation, http: //www.apache.org/
Benchmarking  127.0 . 0.1  (be patient)
Completed  1000  requests
Completed  2000  requests
Completed  3000  requests
Completed  4000  requests
Completed  5000  requests
Completed  6000  requests
Completed  7000  requests
Completed  8000  requests
Completed  9000  requests
Completed  10000  requests
Finished  10000  requests
Server Software:
Server Hostname:         127.0 . 0.1
Server Port:             4444
Document Path:          /
Document Length:         0  bytes
Concurrency Level:       500
Time taken  for  tests:    11.123  seconds
Complete requests:       10000
Failed requests:         0
Write errors:            0
Total transferred:       470000  bytes
HTML transferred:        0  bytes
Requests per second:     899.01  [#/sec] (mean)
Time per request:        556.166  [ms] (mean)
Time per request:        1.112  [ms] (mean, across all concurrent requests)
Transfer rate:           41.26  [Kbytes/sec] received
Connection Times (ms)
               min  mean[+/-sd] median   max
Connect:         0    33  177.0       0     1000
Processing:    500   508   33.9     501     1132
Waiting:       500   508   33.9     501     1132
Total:         500   541  201.8     501     2132
Percentage of the requests served within a certain time (ms)
   50 %     501
   66 %     501
   75 %     502
   80 %     505
   90 %     522
   95 %     532
   98 %    1534
   99 %    1722
  100 %    2132  (longest request)
real    0m11.145s
user    0m0.210s
sys     0m0.961s



012312118.jpg

加到800的时候~

012606797.jpg


gevent：

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
#xiaorui.cc
import  sys
import  socket
import  time
import  gevent
from gevent  import  socket
def server(port):
     s = socket.socket()
     s.bind(( '0.0.0.0' , port))
     s.listen( 500 )
     while  True:
         cli, addr = s.accept()
         gevent.spawn(handle_request, cli, gevent.sleep)
def handle_request(s, sleep):
     try :
         data=s.recv( 1024 )
         sleep( 0.5 )
         s.send( '' 'http/ 1.0  200  OK
                   Hello World!  this  is  xiaorui.cc !!! '' ')
         print data
         request_string =  "GET %s HTTP/1.1\r\nHost: %s\r\n\r\nServer: xiaorui.cc\n"  %( 'index.html' ,  '127.0.0.1' )             
         s.send(request_string)
         s.shutdown(socket.SHUT_WR)
         print  '.' ,‘be killed’
     except Exception, ex:
         print ex
     finally :
                                                                                                                                                                                                                                                                                                                                                                                   
         s.close()
if  __name__ ==  '__main__' :
     server( 7777 )



gevent跑socket服务：

并发数值是500的时候！


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
time ab -n  10000  -c  500  http: //127.0.0.1:7777/
This  is  ApacheBench, Version  2.3  <$Revision:  655654  $>
Copyright  1996  Adam Twiss, Zeus Technology Ltd, http: //www.zeustech.net/
Licensed to The Apache Software Foundation, http: //www.apache.org/
Benchmarking  127.0 . 0.1  (be patient)
Completed  1000  requests
Completed  2000  requests
Completed  3000  requests
Completed  4000  requests
Completed  5000  requests
Completed  6000  requests
Completed  7000  requests
Completed  8000  requests
Completed  9000  requests
Completed  10000  requests
Finished  10000  requests
Server Software:
Server Hostname:         127.0 . 0.1
Server Port:             7777
Document Path:          /
Document Length:         0  bytes
Concurrency Level:       500
Time taken  for  tests:    11.312  seconds
Complete requests:       10000
Failed requests:         0
Write errors:            0
Total transferred:       20000  bytes
HTML transferred:        0  bytes
Requests per second:     884.04  [#/sec] (mean)
Time per request:        565.584  [ms] (mean)
Time per request:        1.131  [ms] (mean, across all concurrent requests)
Transfer rate:           1.73  [Kbytes/sec] received
Connection Times (ms)
               min  mean[+/-sd] median   max
Connect:         0    44  202.7       0     1001
Processing:    500   513   10.1     511      707
Waiting:       500   513   10.1     511      707
Total:         500   557  204.1     512     1525
Percentage of the requests served within a certain time (ms)
   50 %     512
   66 %     515
   75 %     517
   80 %     519
   90 %     531
   95 %     552
   98 %    1521
   99 %    1523
  100 %    1525  (longest request)
real    0m11.334s
user    0m0.159s
sys     0m0.730s

010236465.jpg

服务端看到的信息都是正常的！


010104472.jpg


并发是1000的时候：

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
time ab -n  10000  -c  1000  http: //127.0.0.1:7777/
This  is  ApacheBench, Version  2.3  <$Revision:  655654  $>
Copyright  1996  Adam Twiss, Zeus Technology Ltd, http: //www.zeustech.net/
Licensed to The Apache Software Foundation, http: //www.apache.org/
Benchmarking  127.0 . 0.1  (be patient)
Completed  1000  requests
Completed  2000  requests
Completed  3000  requests
Completed  4000  requests
Completed  5000  requests
Completed  6000  requests
Completed  7000  requests
Completed  8000  requests
Completed  9000  requests
Completed  10000  requests
Finished  10000  requests
Server Software:
Server Hostname:         127.0 . 0.1
Server Port:             7777
Document Path:          /
Document Length:         0  bytes
Concurrency Level:       1000
Time taken  for  tests:    7.406  seconds
Complete requests:       10000
Failed requests:         0
Write errors:            0
Total transferred:       20000  bytes
HTML transferred:        0  bytes
Requests per second:     1350.22  [#/sec] (mean)
Time per request:        740.623  [ms] (mean)
Time per request:        0.741  [ms] (mean, across all concurrent requests)
Transfer rate:           2.64  [Kbytes/sec] received
Connection Times (ms)
               min  mean[+/-sd] median   max
Connect:         0   175  491.7       0     3000
Processing:    500   520   17.7     515      707
Waiting:       500   520   17.7     515      707
Total:         500   695  492.5     517     3521
Percentage of the requests served within a certain time (ms)
   50 %     517
   66 %     523
   75 %     538
   80 %     569
   90 %    1515
   95 %    1530
   98 %    1539
   99 %    3514
  100 %    3521  (longest request)
real    0m7.428s
user    0m0.208s
sys     0m0.741s


当并发到1500的时候：

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
time ab -n  10000  -c  1500  http: //127.0.0.1:7777/
This  is  ApacheBench, Version  2.3  <$Revision:  655654  $>
Copyright  1996  Adam Twiss, Zeus Technology Ltd, http: //www.zeustech.net/
Licensed to The Apache Software Foundation, http: //www.apache.org/
Benchmarking  127.0 . 0.1  (be patient)
Completed  1000  requests
Completed  2000  requests
Completed  3000  requests
Completed  4000  requests
Completed  5000  requests
Completed  6000  requests
Completed  7000  requests
Completed  8000  requests
Completed  9000  requests
Completed  10000  requests
Finished  10000  requests
Server Software:
Server Hostname:         127.0 . 0.1
Server Port:             7777
Document Path:          /
Document Length:         0  bytes
Concurrency Level:       1500
Time taken  for  tests:    5.290  seconds
Complete requests:       10000
Failed requests:         0
Write errors:            0
Total transferred:       20000  bytes
HTML transferred:        0  bytes
Requests per second:     1890.27  [#/sec] (mean)
Time per request:        793.536  [ms] (mean)
Time per request:        0.529  [ms] (mean, across all concurrent requests)
Transfer rate:           3.69  [Kbytes/sec] received
Connection Times (ms)
               min  mean[+/-sd] median   max
Connect:         0   214  404.9       1     1003
Processing:    500   522   23.0     514      716
Waiting:       500   522   23.0     514      716
Total:         500   736  406.7     520     1712
Percentage of the requests served within a certain time (ms)
   50 %     520
   66 %     558
   75 %     602
   80 %    1506
   90 %    1526
   95 %    1531
   98 %    1535
   99 %    1548
  100 %    1712  (longest request)
real    0m5.313s
user    0m0.275s
sys     0m0.763s



出现了少量的报错：

010710202.jpg


gevent 可以加个队列，来限制协程的数目，但是数目限制了，虽然稳定了，但是并发数上不去。

1
2
from gevent.pool  import  Pool
pool = Pool(N)




这里测试有点简单，虽然已经安排了连接的堵塞，但是毕竟不符合业务。 有时间把后端的任务改成才mongodb取数据 ！






 本文转自 rfyiamcool 51CTO博客，原文链接：http://blog.51cto.com/rfyiamcool/1342536，如需转载请自行联系原作者



文章标签：
Python
测试技术
关键词：
Python多线程
Python框架
Python语言
开发Python
socket框架
技术小胖子
目录
相关文章
小白学大数据
|
4月前
|
数据采集 存储 JSON
Python爬取知乎评论：多线程与异步爬虫的性能优化
Python爬取知乎评论：多线程与异步爬虫的性能优化
小白学大数据
255 0
智物科技库
|
4月前
|
人工智能 安全 调度
Python并发编程之线程同步详解
并发编程在Python中至关重要，线程同步确保多线程程序正确运行。本文详解线程同步机制，包括互斥锁、信号量、事件、条件变量和队列，探讨全局解释器锁（GIL）的影响及解决线程同步问题的最佳实践，如避免全局变量、使用线程安全数据结构、精细化锁的使用等。通过示例代码帮助开发者理解并提升多线程程序的性能与可靠性。
智物科技库
174 0
站大爷
|
25天前
|
Java 调度 数据库
Python threading模块：多线程编程的实战指南
本文深入讲解Python多线程编程，涵盖threading模块的核心用法：线程创建、生命周期、同步机制（锁、信号量、条件变量）、线程通信（队列）、守护线程与线程池应用。结合实战案例，如多线程下载器，帮助开发者提升程序并发性能，适用于I/O密集型任务处理。
站大爷
195 0
站大爷
|
3月前
|
数据采集 消息中间件 并行计算
Python多线程与多进程性能对比：从原理到实战的深度解析
在Python编程中，多线程与多进程是提升并发性能的关键手段。本文通过实验数据、代码示例和通俗比喻，深入解析两者在不同任务类型下的性能表现，帮助开发者科学选择并发策略，优化程序效率。
站大爷
228 1
兵临天下19970108016
|
4月前
|
数据采集 监控 调度
干货分享“用 多线程 爬取数据”：单线程 + 协程的效率反超 3 倍，这才是 Python 异步的正确打开方式
在 Python 爬虫中，多线程因 GIL 和切换开销效率低下，而协程通过用户态调度实现高并发，大幅提升爬取效率。本文详解协程原理、实战对比多线程性能，并提供最佳实践，助你掌握异步爬虫核心技术。
兵临天下19970108016
373 0
站大爷
|
5月前
|
JSON 算法 Java
打造终端里的下载利器：Python实现可恢复式多线程下载器
在数字时代，大文件下载已成为日常需求。本文教你用Python打造专业级下载器，支持断点续传、多线程加速、速度限制等功能，显著提升终端下载体验。内容涵盖智能续传、多线程分块下载、限速控制及Rich库构建现代终端界面，助你从零构建高效下载工具。
站大爷
348 1
小白学大数据
|
4月前
|
数据采集 存储 Java
多线程Python爬虫：加速大规模学术文献采集
多线程Python爬虫：加速大规模学术文献采集
小白学大数据
250 0
站大爷
|
5月前
|
数据采集 网络协议 前端开发
Python多线程爬虫模板：从原理到实战的完整指南
多线程爬虫通过并发请求大幅提升数据采集效率，适用于大规模网页抓取。本文详解其原理与实现，涵盖任务队列、线程池、会话保持、异常处理、反爬对抗等核心技术，并提供可扩展的Python模板代码，助力高效稳定的数据采集实践。
站大爷
241 0
Deephub
|
10月前
|
并行计算 安全 Java
Python GIL（全局解释器锁）机制对多线程性能影响的深度分析
在Python开发中，GIL（全局解释器锁）一直备受关注。本文基于CPython解释器，探讨GIL的技术本质及其对程序性能的影响。GIL确保同一时刻只有一个线程执行代码，以保护内存管理的安全性，但也限制了多线程并行计算的效率。文章分析了GIL的必要性、局限性，并介绍了多进程、异步编程等替代方案。尽管Python 3.13计划移除GIL，但该特性至少要到2028年才会默认禁用，因此理解GIL仍至关重要。
Deephub
711 16
Python GIL（全局解释器锁）机制对多线程性能影响的深度分析

热门文章

最新文章

  • 1
    百宝箱开放平台 ✖️ Python SDK
  • 2
    python torch基础用法
  • 3
    Python编程：类型转换与输入输出
  • 4
    从手动编辑到代码生成：Python 助你高效创建 Word 文档
  • 5
    Python中的json模块：从基础到进阶的实用指南
  • 6
    Python定时爬取新闻网站头条：从零到一的自动化实践
  • 7
    Python SQLAlchemy模块：从入门到实战的数据库操作指南
  • 8
    2026版基于python大数据的电影分析可视化系统
  • 9
    基于python大数据的台风灾害分析及预测系统
  • 10
    基于python大数据深度学习的酒店评论文本情感分析系统
  • 1
    阿里云PAI-DLC任务Pytorch launch_agent Socket Timeout问题源码分析
    323
  • 2
    【YashanDB知识库】YAS-00402 failed to connect socket, errno 111
    118
  • 3
    【YashanDB知识库】查询空间数据提示This socket has been closed.
    127
  • 4
    【YashanDB知识库】YAS-00402 failed to connect socket, errno 111, error message "Connection refused"
    145
  • 5
    Socket如何实现客户端和服务器间的通信
    416
  • 6
    # 2个类轻松构建高效Socket通信库
    239
  • 7
    用Apifox调试Socket.IO接口，从原理到实践
    561
  • 8
    Apifox工具让我的 Socket.IO 测试效率翻倍
    287
  • 9
    Socket.IO介绍，以及怎么连接测试Socket.IO接口？
    595
  • 10
    如何调试 Socket.IO 接口？图文教程
    189

    • 相关课程

    更多
  • Python爬虫实战
  • Python开发基础入门
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 推荐镜像

    更多
  • python-release
    • 下一篇
    阿里云对象存储OSS收费标准：500G存储118元1年、