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

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

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

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

  

目录

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

  例如

  

相关介绍

  Python 3.x(面向对象高级语言)多处理(Python库)线程(Python库)Asyncio(Python库)时间(Python库)随机(Python库)

  

实验环境

  进程:运行在操作系统上的一个程序实例称为进程。进程需要相应的系统资源:内存、时间片、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 ()) #确定进程是否还活着。

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

  

进程

  以一个读写程序为例。主函数是主进程,写函数是子进程,读函数是另一个子进程。然后两个子进程进行读写。

  导入操作系统

  导入时间

  随机导入

  从多重处理导入流程,队列

  #写入数据功能

  定义写(q):

  对于[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的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: