大佬对协程以及try except的详细解释
协程中提到的异步指的是两个函数一起运行，各个函数运行到哪里cpu会中断是不一定的。
---------------------------------------------------------------------------------------
协程能执行成百上千个
协程就是并发的一种
并发不是并行,一个协程被阻塞，换其他协程继续上
等待一个结束另一个在启动的都是单线程
虽然不用gevent（毕竟python有自带asyncio）不过异步concurrent的原理都差不多
gevent应该是只有一个event loop再跑。然后切换的是任务gevent做了monkey patch（例如python2没有async sleep这类的支持）
gevent做了monkey patch（例如python2没有async sleep这类的支持）
至于系统看到的线程。那个一直都只有一个。因为python线程是自己做。不是os。所以系统线程数量跟gevent无关（如果看python自己提供的thread count。看到的是一个）
gevent，greenlet跟asyncio这些是指给你（用户）决定什么时候切换。而线程则是python的runtime自己做。并且线程需要stack。这类的异步task则不用
cpu并行你无论开多少个线程实际上都只有一个线程在跑
多进程：很吃cpu的代码
io密集 访问网站，
CPU密集 大量计算的
多线程：io等待。但是同时运行线程在百来个之内（小1-2千也可以，看具体）
协程是什么密集的呢？
异步io（async）io等待。可以做上万task“同时”
python3的话。自己有带asyncio模块。就不用去使用第三方库完成。python2的话。还是要gevent，greenlet，stackless这类的去实现
跑的是一个”event loop”
go不同。go自身的concurrent就是go routine
go routine 设计上就是asyncio这样的（go自身实现的）
所以go很简单： go 函数 就可以了
大多数情况下：多进程+多线程/异步Io（协程）就够了
换个说法：如果你需要多进程+多线程或者异步。那么一般来说。你不用问这些问题的。如果你问这些问题。说明你并不需要用那样的架构
python的进程并不能直接设定cpu affinity。所以是否一个进程一个core没法保证的
如果是linux系统。可以通过cgroups外围形式来设定（开启进程后。在os设定这个进程跑哪个core）
其他系统不知道。core的分配要看os、
进程是否保持跟core一致还是多还是少是根据你需要而定的
多进程也不一定都是跟运算有关
进程是独立的。换句话说。一个进程挂了，其他的进程不影响。主进程不影响
所以设计的时候。也有些是为了稳定而采用多进程的
例如你跑一个服务。你是要长期跑的。你担心有内存泄漏，担心服务异常终止等待。那么一般就是主程序fork自进程初开。主进程做为watchdog。守护你的自进程（并且负责重启等等）
100个建议你直接thread吧
1000个的话。根据需要可能选择携程或者线程。100个基本不用想。直接thread多简单（异步代码会麻烦的多。尤其是异常处理部分，跟callback带callback带callback）
那如果代码中多个“子进程”的话，特定的一个协程有可能在不同的时间间隔被不同的子进程来处理吗？
不会。
也就是说，代码设计的时候，某一个协程一定是“归属于”特定的进程来执行其返回的结果的
除非你自己做一个scheduler。把你的线程/携程移到另外一个进程里面（我不确定是否能真的做出来。不过简单的demo应该可以）
进程就好像你的一个python脚本 你可以写两个文件。运行python 文件名。然后两个文件内的代码随机跑在某个python（这里指的是终端上运行的python pid）上吗？
通信是信息传递。运行就不是信息了。并不是说你把线程/携程直接pickle起来另外一个进程直接unpack读回去就可以
我建议你可以找找进程跟线程的基础书看看。那个会讲的比较全面。也比较正确
看过进程线程之后。可以看看异步IO的东西。因为看过之后你大概就有个概念了。你可以看成：python的thread其实就是python自身维护了一个“thread-loop”
随意python才有线程不能跨核的问题。因为系统（os）看到的只有一个线程而已
python在这个thread-loop中切换在不同的“thread”里面。你使用。就有了“线程”的感觉了
但是python的这个thread-loop是你没法控制的（什么时候等待，什么时候切换）等等。这些都是python自身在运行的时候决定
每个程序（其实严格的说包括进程）内核看到的都是个“线程”
例如c++你开10个线程。os看到的就是10个线程。所以os可以帮你放在不同cpu执行（效率）
因为c++直接用pthread来做。而python的话。os能看到的只是“python”自身。跟你都没关系。是你那个叫做python的指令
你的代码都是在“python”里面。python来处理在做的。对于os来说。跟notepad没有区别
但是python虽然不能直接给你pthread来做线程。但是在自身pyyhon中。也是用一样的机制来架构线程的
我：
python的线程没法跨核，所以被吐槽了
多线程是为了榨干单独一个核的性能
多进程是榨干整个cpu的性能
所以你会有stack size，会有thread的各种属性（用起来感觉跟线程一样）
多线程一般不是为了吃cpu的（哥哥语言都是）主要是避免一些缓慢的等待。例如IO（硬盘读区。网络读取等等）
如果吃cpu。单线程单进程。锁定core（这样os不会帮你跳去其他core）可以把一个core的资源吃光
而异步（asyncio）跟线程最大的区别是。你自己决定。什么时候把使用权给出去
例如你一个代码有5行。跑线程。你不知道在哪行。python就决定。你这个线程使用的cpu够了。换下一个来
所以这五行中任意一行。都可能做为thread的切换点
asyncio则是把loop交给你（用户）手里了
你可以决定。我这5行代码。只有运行到第三行的时候。才会切换出去
这样。你1运行了1一定会运行2然后才出去
2.x没有内置的异步。一般用gevent，greenlet，stackless这类的做
因为你自己做的event，你并没有stack
不像thread。python需要一个标准的stack（记得最小32k）
所以你的性能会好很多。同时，你只有“收到切换”的时候才会切换。就不需要thread那么复杂的scheduler来管理。一般来说。一个系统开1-2千个thread就差不多了。你可以花点功夫。做5-6千个（可以开启，可以跑。但是性能就很不好了）而asyncio做event loop的话。可以轻松做上万
python中比较出名的两个：twisted 跟 tornado
看了下文档。是32k。没记错
threading.stack_size([size])
Return the thread stack size used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 32,768 (32 KiB). I
threading模块文档
tornado是web服务。是“性能比较好”的web服务
性能的来源就在于他们是用asyncio来做的。而不是thread
所以也有很多人。拿tornado代码过来。并不是跑服务。import之后。就用他们的async部分库（python2自己是没有asyncio的）
twisted的async库有点类似node.js。是以defer这样的形式来做
node.js之所以性能好。因为人家是async架构
go之所以很多人喜欢。也是因为是async架构（另外使用比较简单）
python之所以很多人吐槽。不就是GIL（thread不能跨核）跟没有异步嘛
python3带了asyncio。甚至event loop都允许挂自己的（或者第三方）
uvloop这个项目。至少他们自称（自己公布的）测试数据。python3自带的asyncio+uvloop可以达到基本接近go的性能（简单的异步处理）
虽然说不可全信。而且实际应用的话代码会复杂很多，不可能保持那个性能。但是已经是很厉害了
GIl很好拆除呀
网上很多教程的
好想就3-5行代码。注释掉就好了
不过为什么要移除呢？
你真的需要夸核。直接用cython就好了。可以直接lift gil的
如果你程序架构没错（python属于高级语言，很多东西做起来很简单）gil不是问题
不用混编。不过允许你把python直接编译成二进制可执行。允许你混编
另外python不是有芹菜嘛
其实就算python自己带的multiprocessing模块。manager也是可以跨越机器的
有几个语言自带的库。可以让我写代码直接分散到几百个电脑去的？
所以gil其实没什么好抱怨的
业余中大多数情况下：多线程优越于异步IO
就好像汇编语言性能好。也没说人人都在用
就是非专业很多人自己理解力有限
写出来的东西稳定，性能什么的就都有限
省事的多的多多多的多了
写代码不是你看博客看书例子那么简单的
另外一个也算在这个范围的东西。就是event driven了
例如python的select模块
select，pool，epool，kqueue这些
select跟pool应该是各个平台都有支持。epoll只有linux有kqueue只有bsd
unix好像还有一个什么。不记得了。文档应该有写
https://docs.python.org/3/library/select.html
这个python2根3都支持
不过3支持一个新的selectors很好用。这个自动使用select下面的最适合你当前os的方法
也就是说。不用自己写代码分别区分处理linux，osx，windows的区别
例如select.epool或者kqueue也是可以直接单线程上轻松10k链接的东西
select.select是比较老的。有1024的file descriptor的限制
但是我概念上就不理解，如果代码本身已经写成多进程，那么flask中的这个多进程选项processes=N是不是就没用了呢？？？
我就用过一次flask（一共就一天时间。为了写个rest server）
run(host=None, port=None, debug=None, **options)
options – the options to be forwarded to the underlying Werkzeug server. See werkzeug.serving.run_simple() for more information.
所以还不是flask直接用的
我不是做开发的。就写过那么一次web
processes – if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes.
http://werkzeug.pocoo.org/docs/0.14/serving/#werkzeug.serving.run_simple
等于你的route是丢进一个process pool里面的
run的时候process设定的是你的pool的大小
你开pool的话 不运行开始的时候就init了
然后东西都给pool中空闲的资源去处理
处理完了就处理下一个
可以看multiprocessing中的pool那段
flask是做上层的。下面处理http自身的是另外的代码
flask是逻辑
http自身的request是后面的另外那个用。所以process是丢到那边去的
不能直观看到协程 内部有协程队列保存协程状态
总结下：系统只能看到python的主线程，看不到python开的子线程
协程归进程来管，线程不能跨核，协程也不能。
大佬 22:07:33
因为我们公司开发比我厉害的太多了
大佬 22:07:57
我这种水平（甚至测试里面很多比我好的）都还不够开发的标准
大佬 22:09:37
你看flask官网的第一句话：Flask is a microframework for Python based on Werkzeug,
大佬 22:10:03
run里面的process是直接传给werkzeug的
大佬 22:10:55
看文档介绍。感觉就是个pool设定process的数量。具体的实际情况。翻一下werkzeug代码就知道了
太古时代的小鲤鱼 22:13:23
好的，谢谢您~
太古时代的小鲤鱼 22:13:32
我正在整理记录您的话~
好奇，就看了一下flask的run里面的processes这个参数
大佬 22:33:36
flask的run是把参数直接传递给
werkzeug.serving.run_simple
run_simple用这个参数叫了make_serve
make_server说 ：
elif processes > 1:
return ForkingWSGIServer(host, port, app, processes, request_handler, passthrough_errors, ssl_context, fd=fd)
所以这个参数又给了ForkingWSGIServer
ForkingWSGIServer继承了两个class
werkzeug.serving： https://github.com/pallets/werkzeug/blob/master/werkzeug/serving.py
大佬 22:33:43
ForkingWSGIServer(ForkingMixIn, BaseWSGIServer)
self.max_children = processes
大佬 22:34:03
ForkingMixIn又是什么？
if can_fork:
ForkingMixIn = socketserver.ForkingMixIn
else:
class ForkingMixIn(object):
pass
大佬 22:34:16
搞了半天是跳去了python内置的socketserver.ForkingMixin了
大佬 22:34:38
回到python内置部分（socketserver是python自带的）
https://github.com/python/cpython/blob/master/Lib/socketserver.py
大佬 22:34:47
class ForkingMixIn:
"""Mix-in class to handle each request in a new process."""
timeout = 300
active_children = None
max_children = 40
大佬 22:34:53
while len(self.active_children) >= self.max_children:
try:
pid, _ = os.waitpid(-1, 0)
self.active_children.discard(pid)
except ChildProcessError:
# we don't have any children, we're done
self.active_children.clear()
except OSError:
break
大佬 22:35:20
就是直接os.fork出去的子进程做处理
大佬 22:35:30
看完了，就没什么神秘的了
大佬 22:36:40
def process_request(self, request, client_address):
"""Fork a new subprocess to process the request."""
pid = os.fork()
if pid:
大佬 22:37:03
所以就是在处理请求的时候，创建一个新的进程来处理
大佬 22:37:42
直到达到了你给的最大数字
大佬 22:38:01
python自己内定的是开40个进程
大佬 22:38:28
不算是proess pool，因为pool是把process开起来了之后，丢task过去。这个是task来了，再开
大佬 22:38:38
你平时不怎么看代码的关系吧
太古时代的小鲤鱼 22:39:14
是的，直接拿来用了
太古时代的小鲤鱼 22:39:33
大佬 22:40:12
你上班平时不用第三方库？
太古时代的小鲤鱼 22:40:52
分不清哪个是第三方库~
太古时代的小鲤鱼 22:40:55
都没太在意
太古时代的小鲤鱼 22:41:03
虽然上次有人说过一次
就是你import的东西不是python自带的
太古时代的小鲤鱼 22:41:13
但是依然没有留下深刻的音箱
太古时代的小鲤鱼 22:41:18
用啊
大佬 22:41:21
因为python自带的都比较好，文档一定齐全
太古时代的小鲤鱼 22:41:35
可是吧
大佬 22:41:35
如果是其他的，就很难说了，文档不好的时候，都是需要翻看源码的
太古时代的小鲤鱼 22:41:44
源码这东西
太古时代的小鲤鱼 22:41:51
没注释真的看起来挺烦的
大佬 22:42:20
不觉得，python的源码觉得真的很容易看
大佬 22:42:29
其他语言，没有遇到比这个更容易看的
太古时代的小鲤鱼 22:42:37
好吧，大神~
大佬 22:43:56
一般都是这样的
太古时代的小鲤鱼 22:44:08
大佬 22:44:17
第三方库，有些可能基本没有文档，注释不怎么写（请问你写代码会写很多注释给别人看吗？）
太古时代的小鲤鱼 22:44:31
我都写蛮详细的注释
太古时代的小鲤鱼 22:44:34
不过吧
太古时代的小鲤鱼 22:44:36
没人会看
太古时代的小鲤鱼 22:44:41
因为只有我自己一个人写
太古时代的小鲤鱼 22:44:47
python
太古时代的小鲤鱼 22:44:52
没人会去改动他
太古时代的小鲤鱼 22:44:57
所以。。。。也是蛮尴尬的
大佬 22:45:26
所以都是看代码。不过python代码规则比较严谨，一般一种东西也只有一两个做法，所以很容易理解（不像ruby，如果用python的眼光看，那就是一堆monkey patch，简直没法看）
大佬 22:45:43
省事
大佬 22:46:03
不像我们整天都争着抢提交
大佬：
设计模式
算法
架构
大佬 23:22:14
代码架构
代码严谨程度
代码质量：不够。如果写个自己的服务，一般保证几个星期连续运行没有问题。几个月或者一年的那种？不敢给任何保证（现在有个我写的东西，还是平均几个月就挂一次，我都不知道哪里的问题）
大佬 23:24:45
知道的东西：少。毕竟不是做这个的。公司要求用状态机，我才开始看什么是状态机。
公司要求用RX了（ReactiveX）我才看是学什么是RX
try except可以防止挂吗
大佬 23:36:10
try:
xxxx
except Exception as error:
yyy
这样的代码可以后，一般整个项目只能有一个（总入口）用来处理所有的未知错误
太古时代的小鲤鱼 23:36:48
不能一边改一边上线吗？
太古时代的小鲤鱼 23:37:02
感觉您那边应该是属于开发-测试流程很严谨的那种
太古时代的小鲤鱼 23:37:14
我之前待的小公司直接改完bug没怎么测试就上了
太古时代的小鲤鱼 23:37:19
双击查看原图
大佬 23:38:33
一般的代码写法：
try:
你要做的事情
except ValueError as error:
处理 ValueError
except IOError as error:
处理 IOError
except OSError as error:
处理 OSError
raise #丢回上面的stack
except AttributeError as error:
处理 AttributeError
raise ApplicationError(error) #处理一个error，然后raise成其他的
大佬 23:40:07
我在外企
太古时代的小鲤鱼 23:40:10
我的想法是：不能是出错的直接跳过，先继续跑后面的任务吗
太古时代的小鲤鱼 23:40:12
？
大佬 23:40:15
洋人要求比较多
太古时代的小鲤鱼 23:40:18
我知道，您提过
大佬 23:40:27
例如代码没有过系统的测试。都无法提交的
太古时代的小鲤鱼 23:40:35
这样。。。。
太古时代的小鲤鱼 23:40:44
不容易
大佬 23:40:50
try的作用是“抓到你认为会出现的错误”
大佬 23:41:06
如果你try之后的except不写原因。那么很简单，你自己都不知道你代码哪里会错
太古时代的小鲤鱼 23:41:18
对啊
大佬 23:41:43
换句话说，自己写的，自己都不懂的代码，那么谁应该懂？谁应该看？
太古时代的小鲤鱼 23:41:49
就这么搞啊，如果我知道哪里会出错，我直接就改过来了呀，就不用try except了啊
太古时代的小鲤鱼 23:41:50
可是
太古时代的小鲤鱼 23:41:56
他们之前告诉我的是：
太古时代的小鲤鱼 23:42:11
使用try except是在自己不知道哪里会出错的情况下使用的，他们强调说，防止挂掉
大佬 23:42:16
所以那种except拿到所有错误（Exception）的，一个项目只有最外面的那个大出口的 __name__ == '__main__' 下面可以出现一次
太古时代的小鲤鱼 23:42:35
感觉您讲的比他们说的严谨多了
大佬 23:42:40
如果你都不知道出的什么错？你怎么防止挂掉？
大佬 23:42:45
你只是“希望”不会挂掉
太古时代的小鲤鱼 23:42:46
直接pass
太古时代的小鲤鱼 23:42:59
他们说，跑到except那里，可以直接pass
太古时代的小鲤鱼 23:43:10
继续执行下一轮循环或者之后的代码
太古时代的小鲤鱼 23:43:32
那也就是说：您那边的代码都经过系统测试，不怕挂，那么也就是不需要try except了？
23:44:01
你撤回了一条消息
23:44:04
你撤回了一条消息
大佬 23:44:05
例如系统给你一个MemoryError （因为你没有足够的内存了）难道pass系统就自动增加内存了？
大佬 23:44:27
需要很多的try except，但是是你自己知道的东西，自己要去处理
太古时代的小鲤鱼 23:44:51
那想不到的error怎么办
太古时代的小鲤鱼 23:45:06
那种想不到的会导致系统挂掉的error
太古时代的小鲤鱼 23:45:26
之前群里说用try except，听您这么一讲，其实他们是在滥用了
大佬 23:45:42
例如我写个function，接受一个变量，要求这个变量是 JSON 的字符串，然后处理
太古时代的小鲤鱼 23:46:25
我崩掉过，就是网络断网了
太古时代的小鲤鱼 23:46:31
直接崩掉
太古时代的小鲤鱼 23:46:34
没考虑到当时
太古时代的小鲤鱼 23:47:19
您早点休息吧~改天我再请教您~
太古时代的小鲤鱼 23:47:33
太晚了，真不好意思浪费您这么多时间~
太古时代的小鲤鱼 23:47:42
明天您还要上班呢~
大佬 23:25:20
这些很多的东西加在一起，就是说离开发还是很大的距离的。又何必为难自己去做开发呢？
太古时代的小鲤鱼 23:32:07
不是说。。。
太古时代的小鲤鱼 23:32:14
try except可以防止挂吗
太古时代的小鲤鱼 23:32:18
出问题可以继续跑
太古时代的小鲤鱼 23:32:33
设计模式我听说web这块用得比较多
太古时代的小鲤鱼 23:32:40
但是面试官的gitlab我看了
太古时代的小鲤鱼 23:32:46
他其实主要是java
太古时代的小鲤鱼 23:32:53
python这块他没有用过设计模式
太古时代的小鲤鱼 23:33:06
状态机是离散数学里的
太古时代的小鲤鱼 23:33:14
其实我一开始接触状态机是在数字电路里的
太古时代的小鲤鱼 23:33:53
代码架构我也不会
太古时代的小鲤鱼 23:34:12
算法的话，不去做AI，音频和图像，那么基本是用不到的吧
太古时代的小鲤鱼 23:34:17
哎
太古时代的小鲤鱼 23:34:19
早点休息
太古时代的小鲤鱼 23:34:22
谢谢您了
太古时代的小鲤鱼 23:34:25
受益匪浅~
大佬 23:36:10
try:
xxxx
except Exception as error:
yyy
这样的代码可以后，一般整个项目只能有一个（总入口）用来处理所有的未知错误
太古时代的小鲤鱼 23:36:48
不能一边改一边上线吗？
太古时代的小鲤鱼 23:37:02
感觉您那边应该是属于开发-测试流程很严谨的那种
太古时代的小鲤鱼 23:37:14
我之前待的小公司直接改完bug没怎么测试就上了
太古时代的小鲤鱼 23:37:19
大佬 23:38:33
一般的代码写法：
try:
你要做的事情
except ValueError as error:
处理 ValueError
except IOError as error:
处理 IOError
except OSError as error:
处理 OSError
raise #丢回上面的stack
except AttributeError as error:
处理 AttributeError
raise ApplicationError(error) #处理一个error，然后raise成其他的
大佬 23:40:07
我在外企
太古时代的小鲤鱼 23:40:10
我的想法是：不能是出错的直接跳过，先继续跑后面的任务吗
太古时代的小鲤鱼 23:40:12
？
大佬 23:40:15
洋人要求比较多
太古时代的小鲤鱼 23:40:18
我知道，您提过
大佬 23:40:27
例如代码没有过系统的测试。都无法提交的
太古时代的小鲤鱼 23:40:35
这样。。。。
太古时代的小鲤鱼 23:40:44
不容易
大佬 23:40:50
try的作用是“抓到你认为会出现的错误”
大佬 23:41:06
如果你try之后的except不写原因。那么很简单，你自己都不知道你代码哪里会错
太古时代的小鲤鱼 23:41:18
对啊
大佬 23:41:43
换句话说，自己写的，自己都不懂的代码，那么谁应该懂？谁应该看？
太古时代的小鲤鱼 23:41:49
就这么搞啊，如果我知道哪里会出错，我直接就改过来了呀，就不用try except了啊
太古时代的小鲤鱼 23:41:50
可是
太古时代的小鲤鱼 23:41:56
他们之前告诉我的是：
太古时代的小鲤鱼 23:42:11
使用try except是在自己不知道哪里会出错的情况下使用的，他们强调说，防止挂掉
大佬 23:42:16
所以那种except拿到所有错误（Exception）的，一个项目只有最外面的那个大出口的 __name__ == '__main__' 下面可以出现一次
太古时代的小鲤鱼 23:42:35
感觉您讲的比他们说的严谨多了
大佬 23:42:40
如果你都不知道出的什么错？你怎么防止挂掉？
大佬 23:42:45
你只是“希望”不会挂掉
太古时代的小鲤鱼 23:42:46
直接pass
太古时代的小鲤鱼 23:42:59
他们说，跑到except那里，可以直接pass
太古时代的小鲤鱼 23:43:10
继续执行下一轮循环或者之后的代码
太古时代的小鲤鱼 23:43:32
那也就是说：您那边的代码都经过系统测试，不怕挂，那么也就是不需要try except了？
23:44:01你撤回了一条消息
23:44:04你撤回了一条消息
大佬 23:44:05
例如系统给你一个MemoryError （因为你没有足够的内存了）难道pass系统就自动增加内存了？
大佬 23:44:27
需要很多的try except，但是是你自己知道的东西，自己要去处理
太古时代的小鲤鱼 23:44:51
那想不到的error怎么办
太古时代的小鲤鱼 23:45:06
那种想不到的会导致系统挂掉的error
太古时代的小鲤鱼 23:45:26
之前群里说用try except，听您这么一讲，其实他们是在滥用了
大佬 23:45:42
例如我写个function，接受一个变量，要求这个变量是 JSON 的字符串，然后处理
大佬 0:13:07
只好做OOM kill
大佬 0:13:14
进程？如果consumer挂了，不是进程了
大佬 0:13:14
是你整个OS都挂了
大佬 0:13:14
因为producer不停的在queue里面丢东西，最后OS
大佬对协程以及try except的详细解释相关推荐
- php swoole hyperf,【php】Hyperf为什么要关闭Swoole协程短名称
在Hyperf官方文档的服务器要求中提到 并且,在文档的常见问题中也会看到Swoole 短名未关闭这一个tag. 我想问了,那为什么hyperf一定要关闭掉Swoole的协程短名称呢 首先,我们先看一 ...
- python ico_Python协程asynico模块解读
为了搞清楚asynico模块的具体作用,那我们要先明白一些基本概念.一般在爬虫里面,为了加快速度,我们可以使用多进程.多线程.协程,这篇文章详细解读一下这三者的区别的区别.在一个主程序运行的时候,会有 ...
- golang 解析 --- 进程，线程，协程
一.背景 在并发编程中进程和线程是不可忽略的两个概念,他们很好的完成了操作系统或者服务对于高并发的需求,然而随着时代的进步,协程的概念应运而生,本文旨在解释协程相对于进程和线程在高并发环境下的优势,所 ...
- Python协程之协程在手，说走就走
协程在手,说走就走 什么是协程 先介绍–生产者-消费者模式 解释如下 生产者消费者模式并不是GOF提出的23种设计模式之一,23种设计模式都是建立在面向对象的基础之上的,但其实面向过程的编程中也有很多 ...
- python大佬养成计划--协程实现TCP连接
协程实现TCP连接 在网络通信中,每个连接都必须创建新线程(或进程) 来处理,否则,单线程在处理连接的过程中, 无法接受其他客户端的连接.所以我们尝试使用协程来实现服务器对多个客户端的响应. 与单一T ...
- 分析Kotlin协程只挂起不恢复会怎样(是否存在协程泄漏),以及挂起的协程存在哪里?
前言 刚开始正式学协程原理的时候(以前只是学api怎么用),大概是20年6月,也就是bennyhuo大佬出书<深入理解Kotlin协程>的时候,我买了本然后细细研究,我的内心就一直有一个问 ...
- Kotlin 协程 + Spring webflux 开发后端
前言 后端响应式是未来,吞吐量会更大,而资源占用更少,其用到了类似Android系统的Loop(事件循环)机制,而协程可以减少线程等待的消耗,并且同步式的编程方式使代码可读性更高,两个仿佛天生就是一对 ...
- 超牛逼的异步协程爬虫
写在前面: 本来这篇文章只是用来记录一下学习异步协程爬虫的笔记,感谢CSDN的大力支持,引来了很多关注和浏览,也有很多大佬的批评指针. 事先声明:本文只是学习使用,在爬虫的实战应用中还要添加诸多限制, ...
- python是如何实现进程池和线程池的_进程、线程、线程池和协程如何理解？
1.进程.线程.线程池的概念 进程是一个动态的过程,是一个活动的实体.简单来说,一个应用程序的运行就可以被看做是一个进程,而线程,是运行中的实际的任务执行者.可以说,进程中包含了多个可以同时运行的线程 ...
最新文章
- VS2019 开发第一个Windows驱动程序
- Android入门教程免费获取
- Android之项目全部能正常登录但是部分资源没有显示成功的解决办法
- DtCms.ActionLabel.Article.cs
- django自定义模板标签，通过键获取字典的值，屏蔽姓名等隐蔽信息并调用展示到页面上
- 转行经验分享，关于软件测试的感悟，你想知道的都在这里……
- 《程序设计技术》第五章例程
- 解决SQL数据库无法附加
- linux 机房安全管理,提示尊敬的用户您好：您访问的网站被机房安全管理系统拦截怎么办？...
- 微信表情包小程序源码
- 墨刀安装以及基础使用教程
- 刷脸支付代理收益盈利模式
- vue3自定义开发酒店房态时间组件
- u检验、t检验、F检验、卡方检验详细分析
- KindEditor插件（富文本编辑器）的使用
- 美国电视剧特色介绍与分析
- 「微服务架构」基于NGINX的三种微服务参考架构
- 穷站长(QIONGZZ.com) - 国内最大的免费空间站,国内最便宜最稳定的空间
- html5指标源码,一个超准的技术指标源码！
- ARCGIS中style的制作