Python的进程,线程和协程实例分析

这篇“Python的进程,线程和协程实例分析”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Python的进程,线程和协程实例分析”文章吧。

相关介绍

Python是一种跨平台的计算机程序设计语言。是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。

例如

实验环境

• Python 3.x （面向对象的高级语言）

• Multiprocessing（Python库）

• Threading（Python库）

• Asyncio（Python库）

• Time（Python库）

• Random（Python库）

进程

进程：程序运行在操作系统上的一个实例，就称之为进程。进程需要相应的系统资源：内存、时间片、pid(进程号)。 一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所以进程间数据不共享，开销大。

创建进程步骤：

首先要导入 multiprocessing 中的 Process；

创建一个 Process 对象；

创建 Process 对象时，可以传递参数；

使用 start()启动进程；

结束进程。

import os from multiprocessing import Processimport timedef pro_func(name,age,**kwargs):print("进程正在运行,name=%s, age=%d, pid=%d" %(name, age, os.getpid()))print('kwargs参数值',kwargs)time.sleep(0.1)if __name__=="__main__":    p=Process(target=pro_func,args=('Friendship',18),kwargs={'爱好':'Python'})    print('启动进程')    p.start()    print('程是否还在活着:',p.is_alive())# 判断进程进程是否还在活着    time.sleep(0.5)    # 1 秒钟之后，立刻结束进程    print('结束进程')    p.terminate() # 不管任务是否完成，立即终止进程    p.join() # 等待子进程执行结束    print('程是否还在活着:',p.is_alive())# 判断进程进程是否还在活着

注意：进程间不共享全局变量。

多进程

以一个读写程序为例，main函数为一个主进程，write函数为一个子进程，read函数为另一个子进程，然后两个子进程进行读写操作。

import osimport timeimport randomfrom multiprocessing import Process,Queue# 写数据函数def write(q):    for value in ['I','love','Python']:        print('在队列里写入 %s ' % value)        q.put(value)        time.sleep(random.random())# 读数据函数def read(q):    while True:        if not q.empty():            value  = q.get(True)            print('从队列中读取 %s ' % value)            time.sleep(random.random())        else:            breakif __name__=="__main__": # 主进程    # 主进程创建 Queue，并传给各个子进程    q=Queue()    # 创建两个进程    pw=Process(target=write,args=(q,))    pr=Process(target=read,args=(q,))    # 启动子进程 pw    pw.start()    # 等待 pw结束    pw.join()    # 启动子进程 pr    pr.start()    # 等待 pw结束    pr.join()    print('End!')

用进程池对多进程进行操作

from multiprocessing import Manager,Poolimport os,time,randomdef read(q):    print("read进程 启动(%s),主进程为(%s)" % (os.getpid(), os.getppid()))    for i in range(q.qsize()):        print("read进程 从 Queue 获取到消息：%s" % q.get(True))def write(q):    print("write进程 启动(%s),主进程为(%s)" % (os.getpid(), os.getppid()))    for i in "Python":        q.put(i)if __name__=="__main__":    print("主进程(%s) start" % os.getpid())    q = Manager().Queue() # 使用 Manager 中的 Queue    # 定义一个进程池    po = Pool()    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))    po.apply_async(write, (q,))    time.sleep(1) # 先让上面的任务向 Queue 存入数据，然后再让下面的任务开始从中取数据    po.apply_async(read, (q,))    po.close() # 关闭进程池，关闭后 po 不再接收新的请求    po.join() # 等待 po 中所有子进程执行完成，必须放在 close 语句之后    print("(%s) End!" % os.getpid())

线程

线程：调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在一个进程至少有一个线程，叫主线程，而多个线程共享内存(数据共享，共享全局变量)，从而极大地提高了程序的运行效率。

上图，红框表示进程号(PID)为1624的进程，有118个线程。

使用_thread模块实现

import _threadimport timeimport random# 为线程定义一个函数def print_time(threadName):    count = 0    while count < 5:        time.sleep(random.random())        count += 1        print ("%s: %s" % (threadName, time.ctime(time.time())))# 创建两个线程try:    _thread.start_new_thread(print_time, ("Thread-1",))    _thread.start_new_thread(print_time, ("Thread-2",))except:    print ("Error: 无法启动线程")while True:pass

使用 threading 模块实现

# 使用 threading 模块创建线程 import threadingimport timeimport randomclass myThread(threading.Thread):    def __init__(self, threadID, name):        threading.Thread.__init__(self)        self.threadID = threadID        self.name = name        self.delay = random.random()    def run(self):        print ("开始线程：" + self.name)        print_time(self.name, 5)        print ("退出线程：" + self.name)def print_time(threadName, count):    while count:        time.sleep(random.random())        print ("%s: %s" % (threadName, time.ctime(time.time())))        count -= 1# 创建两个线程thread1 = myThread(1, "Thread-1")thread2 = myThread(2, "Thread-2")# 开启新线程thread1.start()thread2.start()thread1.join()thread2.join()print ("退出主线程")

协程

• 协程：是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。 协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

• 当出现IO阻塞的时候，由协程的调度器进行调度，通过将数据流立刻yield掉(主动让出)，并且记录当前栈上的数据，阻塞完后立刻再通过线程恢复栈，并把阻塞的结果放到这个线程上去跑，这样看上去好像跟写同步代码没有任何差别，这整个流程可以称为coroutine。

• 由于协程的暂停完全由程序控制，发生在用户态上;而线程的阻塞状态是由操作系统内核来进行切换，发生在内核态上。因此，协程的开销远远小于线程的开销。

使用asyncio模块实现

import asyncioimport timeimport randomasync def work(msg):    print("收到的信息:'{}'".format(msg))    print("{}1{}".format("*"*10,"*"*10)) # 为了方便，展示结果    await asyncio.sleep(random.random())    print("{}2{}".format("*"*10,"*"*10)) # 为了方便，展示结果    print(msg)async def main():# 创建两个任务对象(协程)，并加入到事件循环中    Coroutines1 = asyncio.create_task(work("hello"))    Coroutines2 = asyncio.create_task(work("Python"))    print("开始时间: {}".format(time.asctime(time.localtime(time.time()))))    await Coroutines1  # 此时并发运行Coroutines1和Coroutines2    print("{}3{}".format("*"*10,"*"*10)) # 为了方便，展示结果    await Coroutines2 # await相当于挂起当前任务，去执行其他任务，此时是堵塞的    print("{}4{}".format("*"*10,"*"*10)) # 为了方便，展示结果    print("结束时间:{}".format(time.asctime(time.localtime(time.time()))))asyncio.run(main())# asyncio.run(main())创建一个事件循环，并以main为主要程序入口

以上就是关于“Python的进程,线程和协程实例分析”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注编程网行业资讯频道。