资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/python协程与golang协程的区别

python协程与golang协程的区别

csRyan / 1783人阅读

摘要：进程线程和协程进程的定义进程，是计算机中已运行程序的实体。协程和线程的关系协程是在语言层面实现对线程的调度，避免了内核级别的上下文消耗。和都引入了消息调度系统模型，来避免锁的影响和进程线程开销大的问题。

进程、线程和协程 进程的定义：

进程，是计算机中已运行程序的实体。程序本身只是指令、数据及其组织形式的描述，进程才是程序的真正运行实例。

线程的定义：

操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

进程和线程的关系：

一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
CPU的最小调度单元是线程不是进程，所以单进程多线程也可以利用多核CPU.

协程的定义：

协程通过在线程中实现调度，避免了陷入内核级别的上下文切换造成的性能损失，进而突破了线程在IO上的性能瓶颈。

协程和线程的关系

协程是在语言层面实现对线程的调度，避免了内核级别的上下文消耗。

python协程与调度

Python的协程源于yield指令。yield有两个功能:

yield item用于产出一个值，反馈给next()的调用方。

作出让步，暂停执行生成器，让调用方继续工作，直到需要使用另一个值时再调用next()。

import asyncio


async def compute(x, y):
    print("Compute %s + %s ..." % (x, y))
    await asyncio.sleep(x + y)
    return x + y


async def print_sum(x, y):
    result = await compute(x, y)
    print("%s + %s = %s" % (x, y, result))


loop = asyncio.get_event_loop()
tasks = [print_sum(1, 2), print_sum(3, 4)]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

协程是对线程的调度，yield类似惰性求值方式可以视为一种流程控制工具，
实现协作式多任务,在Python3.5正式引入了 async/await表达式，使得协程正式在语言层面得到支持和优化，大大简化之前的yield写法。
线程是内核进行抢占式的调度的，这样就确保了每个线程都有执行的机会。
而 coroutine 运行在同一个线程中，由语言的运行时中的 EventLoop（事件循环）来进行调度。
和大多数语言一样，在 Python 中，协程的调度是非抢占式的，也就是说一个协程必须主动让出执行机会，其他协程才有机会运行。
让出执行的关键字就是 await。也就是说一个协程如果阻塞了，持续不让出 CPU，那么整个线程就卡住了，没有任何并发。

PS: 作为服务端，event loop最核心的就是IO多路复用技术，所有来自客户端的请求都由IO多路复用函数来处理;作为客户端，event loop的核心在于利用Future对象延迟执行，并使用send函数激发协程,挂起,等待服务端处理完成返回后再调用CallBack函数继续下面的流程 Go的协程

Go天生在语言层面支持，和Python类似都是采用了关键字，而Go语言使用了go这个关键字，可能是想表明协程是Go语言中最重要的特性。
go协程之间的通信，Go采用了channel关键字。

Go实现了两种并发形式:

多线程共享内存。如Java或者C++等在多线程中共享数据（例如数组、Map、或者某个结构体或对象）的时候，通过锁来访问.

Go语言特有的，也是Go语言推荐的：CSP（communicating sequential processes）并发模型。

Go的CSP并发模型实现：M, P, G : [https://www.cnblogs.com/sunsk...]

package main

import (
    "fmt"
)

//Go 协程（goroutines）和协程（coroutines）
//Go 协程意味着并行（或者可以以并行的方式部署），协程一般来说不是这样的
//Go 协程通过通道来通信；协程通过让出和恢复操作来通信

// 进程退出时不会等待并发任务结束，可用通道（channel）阻塞，然后发出退出信号
func main() {
    jobs := make(chan int)
    done := make(chan bool) // 结束标志

    go func() {
        for {
            j, more := <-jobs //  利用more这个值来判断通道是否关闭，如果关闭了，那么more的值为false，并且通知给通道done
            fmt.Println("----->:", j, more)
            if more {
                fmt.Println("received job", j)
            } else {
                fmt.Println("end received jobs")
                done <- true
                return
            }
        }
    }()

    go func() {
        for j := 1; j <= 3; j++ {
            jobs <- j
            fmt.Println("sent job", j)
        }
        close(jobs) // 写完最后的数据,紧接着就close掉
        fmt.Println("close(jobs)")
    }()

    fmt.Println("sent all jobs")
    <-done // 让main等待全部协程完成工作
}


通过在函数调用前使用关键字 go，我们即可让该函数以 goroutine 方式执行。goroutine 是一种 比线程更加轻盈、更省资源的协程。
Go 语言通过系统的线程来多路派遣这些函数的执行，使得 每个用 go 关键字执行的函数可以运行成为一个单位协程。
当一个协程阻塞的时候，调度器就会自 动把其他协程安排到另外的线程中去执行，从而实现了程序无等待并行化运行。
而且调度的开销非常小，一颗 CPU 调度的规模不下于每秒百万次，这使得我们能够创建大量的 goroutine，
从而可以很轻松地编写高并发程序，达到我们想要的目的。 ---- 某书
协程的4种状态

Pending

Running

Done

Cacelled

和系统线程之间的映射关系

go的协程本质上还是系统的线程调用，而Python中的协程是eventloop模型实现，所以虽然都叫协程，但并不是一个东西.
Python 中的协程是严格的 1:N 关系，也就是一个线程对应了多个协程。虽然可以实现异步I/O，但是不能有效利用多核(GIL)。
而 Go 中是 M:N 的关系，也就是 N 个协程会映射分配到 M 个线程上，这样带来了两点好处：

多个线程能分配到不同核心上,CPU 密集的应用使用 goroutine 也会获得加速.

即使有少量阻塞的操作，也只会阻塞某个 worker 线程，而不会把整个程序阻塞。

PS: Go中很少提及线程或进程,也就是因为上面的原因. 两种协程对比:

async是非抢占式的,一旦开始采用 async 函数，那么你整个程序都必须是 async 的，不然总会有阻塞的地方(一遇阻塞对于没有实现异步特性的库就无法主动让调度器调度其他协程了)，也就是说 async 具有传染性。

Python 整个异步编程生态的问题，之前标准库和各种第三方库的阻塞性函数都不能用了，如:requests,redis.py,open 函数等。所以 Python3.5后加入协程的最大问题不是不好用，而是生态环境不好,历史包袱再次上演,动态语言基础上再加上多核之间的任务调度,应该是很难的技术吧,真心希望python4.0能优化或者放弃GIL锁,使用多核提升性能。

goroutine 是 go 与生俱来的特性，所以几乎所有库都是可以直接用的，避免了 Python 中需要把所有库重写一遍的问题。

goroutine 中不需要显式使用 await 交出控制权，但是 Go 也不会严格按照时间片去调度 goroutine，而是会在可能阻塞的地方插入调度。goroutine 的调度可以看做是半抢占式的。

PS: python异步库列表 [https://github.com/timofurrer...]

Do not communicate by sharing memory; instead, share memory by communicating.(不要以共享内存的方式来通信，相反，要通过通信来共享内存) -- CSP并发模型

扩展与总结

erlang和golang都是采用了CSP(Communicating Sequential Processes)模式(Python中的协程是eventloop模型)
但是erlang是基于进程的消息通信，go是基于goroutine和channel的通信。
Python和Go都引入了消息调度系统模型，来避免锁的影响和进程/线程开销大的问题。
协程从本质上来说是一种用户态的线程，不需要系统来执行抢占式调度，而是在语言层面实现线程的调度。
因为协程不再使用共享内存/数据，而是使用通信来共享内存/锁，因为在一个超级大系统里具有无数的锁，
共享变量等等会使得整个系统变得无比的臃肿，而通过消息机制来交流，可以使得每个并发的单元都成为一个独立的个体，
拥有自己的变量，单元之间变量并不共享，对于单元的输入输出只有消息。
开发者只需要关心在一个并发单元的输入与输出的影响，而不需要再考虑类似于修改共享内存/数据对其它程序的影响。

云服务器 GPU云服务器 python协程 python协程池 python3协程 协程

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/43738.html

相关文章

  • 谈谈Python协程技术的演进

    摘要：事件循环是异步编程的底层基石。对事件集合进行轮询，调用回调函数等一轮事件循环结束，循环往复。协程直接利用代码的执行位置来表示状态，而回调则是维护了一堆数据结构来处理状态。时代的协程技术主要是，另一个比较小众。 Coding Crush Python开发工程师 主要负责岂安科技业务风险情报系统redq。 引言 1.1. 存储器山 存储器山是 Randal Bryant 在《深入...

    zhiwei 评论0 收藏0

  • PyTips 0x13 - Python 线程与协程（2）

    摘要：项目地址我之前翻译了协程原理这篇文章之后尝试用了模式下的协程进行异步开发，确实感受到协程所带来的好处至少是语法上的。 项目地址：https://git.io/pytips 我之前翻译了Python 3.5 协程原理这篇文章之后尝试用了 Tornado + Motor 模式下的协程进行异步开发，确实感受到协程所带来的好处（至少是语法上的:D）。至于协程的 async/await 语法是如...

    史占广 评论0 收藏0

  • Python中的协程

    摘要：协程的基本行为协程包含四种状态等待开始执行。协程中重要的两个方法调用方把数据提供给协程。注意使用调用协程时会自动预激，因此与装饰器不兼容标准库中的装饰器不会预激协程，因此能兼容句法。因此，终止协程的本质在于向协程发送其无法处理的异常。 导语：本文章记录了本人在学习Python基础之控制流程篇的重点知识及个人心得，打算入门Python的朋友们可以来一起学习并交流。 本文重点： 1、掌握协...

    shinezejian 评论0 收藏0

  • 【宇润日常疯测-007】Swoole 协程与传统 fpm 同步模式比较

    摘要：初识协程执行结果协程与同步模式比较我们一直在说协程适合用于密集场景，在同样的硬件配置环境下，它会比传统的同步模式承载更多的访问量。假设一次查询为，在传统同步模式下，当前进程在这的时间里，是不能做其它操作的。同步模式，耗费左右的是。 如果说数组是 PHP 的精髓，数组玩得不6的，根本不能算是会用PHP。那协程对于 Swoole 也是同理，不理解协程去用 Swoole，那就是在瞎用。 首先...

    henry14 评论0 收藏0

  • python大佬养成计划----协程

    摘要：协程，又称微线程，纤程。最大的优势就是协程极高的执行效率。生产者产出第条数据返回更新值更新消费者正在调用第条数据查看当前进行的线程函数中有，返回值为生成器库实现协程通过提供了对协程的基本支持，但是不完全。 协程，又称微线程，纤程。英文名Coroutine协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。 最大的优势就是协程极高...

    svtter 评论0 收藏0

发表评论

登陆后可评论

0条评论

csRyan

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<