python线程与协程,python的协程和多线程

　　本文主要详细介绍Python进程、线程和协程。本文中的示例代码非常详细，具有一定的参考价值。感兴趣的朋友可以参考一下，希望能帮到你。

　　00-1010前言前提条件相关实验环境介绍进程多进程使用进程池操作多进程线程使用_thread模块实现协同进程使用asyncio模块实现总结

前言

　　熟悉Python的基本语法和Python操作流程、线程、协程的相关库。

前提条件

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

　　举个例子，

实验环境

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

　　创建进程步骤：

　　1.一、导入流程；在多重处理中；

　　2.创建流程对象；

　　3.创建流程对象时，可以传递参数；

　　4.用start()启动流程；

　　5.结束流程。

　　导入操作系统

　　从多重处理导入流程

　　导入时间

　　def pro_func(姓名，年龄，**kwargs):

　　Print(进程正在运行，名称=% s，年龄=% d，PID=% d%(名称，年龄，os.getpid()))

　　打印(“kwargs参数值”，kwargs)

　　时间.睡眠(0.1)

　　if __name__==__main__:

　　P=process (target=pro _ func，args=(friendship ，18)，kwargs={hobby 3360 Python})

　　打印(“开始流程”)

　　开始()

　　Print(进程是否还活着3360 ，p.is _ alive ()) #确定进程是否还活着。

　　时间.睡眠(0.5)

　　# 1秒钟后，立即结束该过程。

　　打印(“结束流程”)

　　P.terminate() #不管任务是否完成，立即终止进程。

　　P.join() #等待子进程的执行完成。

　　Print(进程是否还活着3360 ，p.is _ alive ()) #确定进程是否还活着。

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

进程

　　以一个读写程序为例。主函数是主进程，写函数是子进程，读函数是

　　另一个子进程，然后两个子进程进行读写操作。

import os
　　import time
　　import random
　　from 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:
　　 break
　　if __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,Pool
　　import os,time,random
　　def 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 _thread
　　import time
　　import 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 threading
　　import time
　　import random
　　class 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 asyncio
　　import time
　　import random
　　async 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为主要程序入口

总结

进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所以进程间数据不共享，开销大。
线程：调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在一个进程至少有一个线程，叫主线程，而多个线程共享内存(数据共享，共享全局变量)，从而极大地提高了程序的运行效率。
协程：是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

　　本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注盛行IT软件开发工作室的更多内容!

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。