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

多线程与gevent对比
最新推荐文章于 2022-05-10 21:30:36 发布
转载 最新推荐文章于 2022-05-10 21:30:36 发布 · 133 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://yq.aliyun.com/articles/402590
文章标签：

#python #数据库 #后端

本文通过实际测试比较了多线程与gevent在处理大量并发TCP连接时的表现。测试结果显示，在面对高并发场景时，gevent相较于多线程表现出更好的性能。

测试下多线程和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 接口并发测试详解
悦分享
10-23 8627
性能测试是通过自动化测试工具模拟多种正常、峰值及异常负载条件对系统的各项性能指标进行的测试。负载测试和压力测试都属于性能测试，两者可以结合进行。通过负载测试，确定在各种工作负载下系统的性能，目标是测试当负载逐渐增加时，系统各项性能指标的变化情况。压力测试是通过确定一个系统的瓶颈或者不能接受的性能点，来获得系统能提供的最大服务级别的测试。性能测试的重点是测试在并发条件下服务或系统的瓶颈所在，从而优化相关功能，可能涉及软件及硬件的多方面改进。由此可见，性能测试对整个产品非常重要，甚至可以决定一个产品是否能长久发
python tcp服务器并发_TCP 百万并发 数据连接测试 python+locust
weixin_39951930的博客
12-19 1016
过程笔记和总结尝试一、locust 测试百万Tcp并发另一种方式是使用jmeter基础环境服务端虚拟机：Centos7.2jdk 1.8客户端虚拟机： Centos7.2python : 3.7.3 Anaconda3locust : 0.14.5基础知识：tcp协议：三次握手进行连接，四次挥手断开，稳定长连接，比Http更占用资源，比udp协议更稳定，保证数据不丢失，但速度比较慢。每个tc...
go学习（十三）——Go 语言socket用户并发请求性能测试
天天water的专栏
10-10 9447
前言： 测试环境： windows10虚拟机vmware安装的centos6.9 内存2g，处理器数量2个，每个处理器核心数量2个 Go版本  go1.7.3 linux/amd64 说明： 本次测试目的：本次测试Go语言的网络服务端在处理大量并发请求时的耗用时间。 测试程序： 服务端程序： package main import ( "fmt" "log"
gevent 并发实例
测试0901-1
07-22 145
gevent实例: from gevent import monkey monkey.patch_socket() import gevent import gevent.pool import requests from bs4 import BeautifulSoup import time t1=time.time() #获得所有教授的链接 web_links='http://ww...
python 基于 gevent 完成C/S 服务器协程多并发案例
Zok的博客
06-20 943
gevent 解决单线程内并发 如果再配合多线程，那么可以优化更进一步优化扛住高并发 服务器 from gevent import monkey, spawn; monkey.patch_all() # 使用gevent必须 调用 import socket ...
Python多线程之gevent
Time_xiaoxia的博客
09-01 1217
python多线程只gevent 因为python线程的性能问题，在python中使用多线程运行代码经常不能达到预期的效果。而有些时候我们的逻辑中又需要开更高的并发，或者简单的说，就是让我们的代码跑的更快，在同样时间内执行更多的有效逻辑、减少无用的等待。gevent就是一个现在很火、支持也很全面的python第三方协程库。 gevent是python的一个并发框架，以微线程greenlet为核心，使用了epoll事件监听机制以及诸多其他优化而变得高效。而且其中有个monkey类，将现有基于Python线程直
python单线程下实现多个socket并发过程详解
09-18
在不考虑gevent的情况下，传统的并发模型包括多线程（threading）和多进程（multiprocessing）。多线程适合IO密集型任务，而多进程则适合CPU密集型任务。在代码示例中，我们看到如何使用Python的threading和...
python3 - 基于 gevent 模块，实现服务端单线程下多协程，套接字并发通信
LIN的博客
09-10 368
服务端 from gevent import monkey;monkey.patch_all() import socket import struct, json from gevent import spawn def task(conn, c_add): ''' 在子线程内，实现对应客户端等待输入和数据处理 :param conn: :return: ...
Gevent中爬虫与多线程详解
lidiya007的博客
01-05 1747
gevent实现爬虫并与普通多线程比较 1.爬虫目的与思路简介； 2.gevent实现爬虫； 3.多线程实现爬虫； 4.对比。 爬虫目的与设计 1.从一个主页爬取相关链接； 2.比如麦子学院主站； 3.http://www.maiziedu.com； 4.从此网站爬取内容，分析过滤有效的不重复的网址（不包含图片，视频等资源地址）； 5.但是为了控制结束条件，可以设置爬虫深入和总
python gevent asyncio_同步、异步（gevent，asyncio）、多线程（threading)效率对比
weixin_39935903的博客
12-11 1054
对比了三种情况下采集50个网页所需时间，可以看出多线程在效率上是远高于gevent的。第一次测试的时候，没有使用monkey这个补丁，socket是阻塞调用的，效率并没有提升，因为还是同步运行的，使用monkey补丁后，使socket变为协作运行，效率大大提升。Python的运行环境允许我们在运行时修改大部分的对象，包括模块，类甚至函数。 这是个一般说来令人惊奇的坏主意，因为它创造了“隐式的副作用...
Python 高性能并发框架 Gevent、后门程序
热门推荐
freeking101的博客
11-09 6万+
gevent 是一个基于协程的 Python 网络库，它使用 greenlet 在 libev 或 libuv 事件循环之上提供高级同步 API。gevent 实现了python 标准库里面大部分的阻塞式系统调用，包括 socket、ssl、threading 和 select 等模块，可以使用 "猴子补丁" 将这些阻塞式调用变为协作式运行。
【Python】基于gevent 轻松实现百万级并发
XavierJ的博客
05-10 1561
引言 因为研究需要，最近在研究 Python 的异步编程。Python 内置的标准库 asyncio 初次体验感觉很复杂，并且不支持同步编写第三方库，比如 requests。虽然有一个内置的名为 asyncio 的异步库但是又得重新学习接口。 好在笔者发现了一个非常好用的第三方库 gevent，该库可以轻松实现基于协程的并发，而无需修改原来的同步代码。你仅仅需要将同步编写的函数使用 gevent 进行封装，就能实现用户级别的显式任务调度。 方法 简单设计一个模拟实验测试 gevent 的并发效果。使用 ti
dubbo是长连接还是短连接_百万级别长连接，并发测试指南
weixin_39729784的博客
11-10 621
结尾有彩蛋哟！前言都说haproxy很牛x, 可是测试的结果实在是不算满意, 越测试越失望,无论是长连接还是并发, 但是测试的流程以及工具倒是可以分享分享。也望指出不足之处。100w的长连接实在算不上太难的事情，不过对于网上关于测试方法以及测试工具的相关文章实在不甚满意，才有本文。本文有两个难点,我算不上完全解决。后端代码的性能.linux内核参数的优化.环境说明下面所有的测试机器都是基于open...
python3 协程gevent介绍并实现多客户端并发通信socket
xianjie0318的博客
07-05 1298
协程的概念 协程，又称微线程，纤程。英文名Coroutine。 线程是系统级别的它们由操作系统调度，而协程则是程序级别的由程序根据需要自己调度。在一个线程中会有很多函数，我们把这些函数称为子程序，在子程序执行过程中可以中断去执行别的子程序，而别的子程序也可以中断回来继续执行之前的子程序，这个过程就称为协程。也就是说在同一线程内一段代码在执行过程中会中断然后跳转执行别的代码，接着在之前中断的地方继续开始执行，类似与yield操作。 协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到
Gevent-Socketio Module-Socketio
jrlapple的专栏
01-02 2146
Gevent-Socketio 的socketio模块 相关文档
Python实战之协程（greenlet模块，gevent模块，socket+ gevent实现高并发处理）
Burgess_zheng的博客
01-05 947
上一篇：Python实战之线程点击跳转 目录篇：python相关目录篇 点击跳转 下一篇：python实战之Queue队列模块 点击跳转 同类篇：Python实战之processing进程 点击跳转 目录 协程介绍 linux第三方库安装greenlet  gevent 实战greenlet 实战Gevent 实战协程并发爬网页 和 列表for调用同步串行爬网页的区别和效率 实战so...
python-gevent模块实现socket大并发
weixin_33729196的博客
06-27 448
服务器端：gevent_server.py import sys import socket import time import gevent from gevent import socket, monkey monkey.patch_all() def server(port): s = socket.socket() s.bind(('...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值