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

　　本文主要介绍Python高级教程的线程进程和协同进程的代码分析，包括一个使用线程模块的简单例子。这篇文章给你做了非常详细的介绍，对你的学习或者工作有一定的参考价值。有需要的朋友可以参考一下。

　　00-1010进程、进程、进程、五种基本状态、进程的特征、进程间的数据共享、进程池进程的缺点、线程的定义、线程模块的简单示例、代码分析、线程的协同学和执行、Python协同学、协同学、关闭协同学、链接协同学创建管道摘要

目录

　　进程是指运行在系统中的应用程序，是CPU最小的工作单位。

进程

　　一个进程至少有五种基本状态：初始状态、就绪状态、等待(阻塞)状态、执行状态和终止状态。

　　初始状态：流程刚刚被创建。因为其他进程都在占用CPU资源，无法执行，所以只能处于初始状态。就绪状态：只有那些处于就绪状态的才能被调度到执行状态。等待状态：流程等待事件完成。执行状态：任何时候只能有一个进程处于执行状态(对于单核CPU)。停止：流程结束。

进程 5 种基本状态

　　动态性：进程是一个程序的执行过程，动态地产生和消亡。独立性：进程是可以独立运行的基本单元。它是系统资源分配和调度的基本单元。并发性：任何进程都可以与其他进程并发执行。结构：过程由三部分组成：程序、数据和过程控制块。多处理是比fork更高级的库，使用多处理更容易实现多进程程序。

　　#!/usr/bin/env python

　　# -*-编码：utf-8 -*-

　　从多重处理导入流程

　　导入线程

　　导入时间

　　国防粮食(一):

　　打印“问好”，我

　　对于范围(10):内的I

　　p=进程(target=foo，args=(i，))

　　开始()

　　注意：因为进程之间的数据需要单独保存，所以创建进程需要很大的开销。而且python不能在Windows下创建进程！

　　使用多个进程时，最好创建与CPU核心数量相等的进程。

进程的特点

　　系统中的进程与其他进程共享CPU和主存资源。为了更好地管理主存，操作系统提供了主存的抽象概念，即虚拟内存(VM)。这也是一个抽象的概念，它为每个进程提供了一个错觉，即每个进程都在独占使用主存。

　　虚拟内存主要提供三种功能：

　　主存被视为存储在磁盘上的缓存，其中只保存活动区，数据根据需要在磁盘和主存之间来回传递。这样，更有效地使用主存储器来为每个进程提供一致的地址空间，从而简化了存储器管理并保护每个进程的地址空间不被其他进程破坏。因为进程有自己独占的虚拟地址空间，CPU通过地址翻译把虚拟地址转换成真实的物理地址，每个进程只能访问自己的地址空间。因此，如果没有其他机制(进程间通信)的帮助，进程就无法共享数据。

　　每个进程持有数据的一个副本，所以默认情况下不可能共享数据。默认流程相互独立。如果你想在进程间共享数据，你必须有一个特殊的数据结构。这种数据结构可以理解为具有穿墙功能。如果能穿墙，两边都可以。

　　#!/usr/bin/env python

　　#编码：utf-8

　　从多重处理导入流程

　　从多重处理导入管理器

　　导入时间

　　e

　　li = []

　　def foo(i):

　　 li.append(i)

　　 print say hi,li

　　for i in range(10):

　　 p = Process(target=foo,args=(i,))

　　 p.start()

　　print ending,li

　　使用特殊的数据类型，来进行穿墙：

#通过特殊的数据结构：数组（Array）
　　from multiprocessing import Process,Array
　　#创建一个只包含数字类型的数组（python中叫列表）
　　#并且数组是不可变的，在C，或其他语言中，数组是不可变的，之后再python中数组（列表）是可以变得
　　#当然其他语言中也提供可变的数组
　　#在C语言中数组和字符串是一样的，如果定义一个列表，如果可以增加，那么我需要在你内存地址后面再开辟一块空间，那我给你预留多少呢？
　　#在python中的list可能用链表来做的，我记录了你前面和后面是谁。列表不是连续的，数组是连续的
　　上面不是列表是“数组"数组是不可变的，附加内容是为了更好的理解数组！
　　temp = Array(i, [11,22,33,44]) #这里的i是C语言中的数据结构，通过他来定义你要共享的内容的类型！点进去看~
　　def Foo(i):
　　 temp[i] = 100+i
　　 for item in temp:
　　 print i,----->,item
　　for i in range(2):
　　 p = Process(target=Foo,args=(i,))
　　 p.start()
　　第二种方法：
　　#方法二：manage.dict()共享数据
　　from multiprocessing import Process,Manager #这个特殊的数据类型Manager
　　manage = Manager()
　　dic = manage.dict() #这里调用的时候，使用字典，这个字典和咱们python使用方法是一样的！
　　def Foo(i):
　　 dic[i] = 100+i
　　 print dic.values()
　　for i in range(2):
　　 p = Process(target=Foo,args=(i,))
　　 p.start()
　　 p.join()

　　既然进程之间可以进行共享数据，如果多个进程同时修改这个数据是不是就会造成脏数据？是不是就得需要锁！

　　进程的锁和线程的锁使用方式是非常一样的知识他们是用的类是在不同地方的。

进程池

　　进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

　　进程池中有两个方法：

• apply
• apply_async

#!/usr/bin/env python
　　# -*- coding:utf-8 -*-
　　from multiprocessing import Process,Pool
　　import time
　　def Foo(i):
　　 time.sleep(2)
　　 return i+100
　　def Bar(arg):
　　 print arg
　　pool = Pool(5) #创建一个进程池
　　#print pool.apply(Foo,(1,))#去进程池里去申请一个进程去执行Foo方法
　　#print pool.apply_async(func =Foo, args=(1,)).get()
　　for i in range(10):
　　 pool.apply_async(func=Foo, args=(i,),callback=Bar)
　　print end
　　pool.close()
　　pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。
　　apply 主动的去执行
　　pool.apply_async(func=Foo, args=(i,),callback=Bar) 相当于异步，当申请一个线程之后，执行FOO方法就不管了，执行完之后就在执行callback ，当你执行完之后，在执行一个方法告诉我执行完了
　　callback 有个函数，这个函数就是操作的Foo函数的返回值！
　　

进程的缺点

　　无法即时完成的任务带来大量的上下文切换代价与时间代价。

　　进程的上下文：当一个进程在执行时，CPU的所有寄存器中的值、进程的状态以及堆栈中的内容被称为该进程的上下文。

　　上下文切换：当内核需要切换到另一个进程时，它需要保存当前进程的所有状态，即保存当前进程的上下文，以便在再次执行该进程时，能够得到切换时的状态并执行下去。

线程

线程的定义

　　在计算中，进程是正在执行的计算机程序的一个实例。任何进程都有 3 个基本组成部分：

• 一个可执行程序。
• 程序所需的相关数据（变量、工作空间、缓冲区等）
• 程序的执行上下文（进程状态）

　　线程是进程中可以调度执行的实体。此外，它是可以在 OS（操作系统）中执行的最小处理单元。

　　简而言之，线程是程序中的一系列此类指令，可以独立于其他代码执行。为简单起见，您可以假设线程只是进程的子集！

　　线程在线程控制块 (TCB)中包含所有这些信息：

• 线程标识符：为每个新线程分配唯一 id (TID)
• 堆栈指针：指向进程中线程的堆栈。堆栈包含线程范围内的局部变量。
• 程序计数器：存放线程当前正在执行的指令地址的寄存器。
• 线程状态：可以是running、ready、waiting、start或done。
• 线程的寄存器集：分配给线程进行计算的寄存器。
• 父进程指针：指向线程所在进程的进程控制块 (PCB) 的指针。

　　多线程被定义为处理器同时执行多个线程的能力。

在一个简单的单核 CPU 中，它是通过线程之间的频繁切换来实现的。这称为上下文切换。在上下文切换中，只要发生任何中断（由于 I/O
或手动设置），就会保存一个线程的状态并加载另一个线程的状态。上下文切换发生得如此频繁，以至于所有线程似乎都在并行运行（这被称为多任务）。

　　

　　在 Python 中，threading模块提供了一个非常简单直观的 API，用于在程序中生成多个线程。

使用线程模块的简单示例

　　让我们考虑一个使用线程模块的简单示例：

# Python程序说明线程的概念
　　# 导入线程模块
　　import threading
　　def print_cube(num):
　　 """
　　 打印给定数字立方的函数
　　 """
　　 print("立方: {}".format(num * num * num))
　　def print_square(num):
　　 """
　　 打印给定数字平方的函数
　　 """
　　 print("平方: {}".format(num * num))
　　if __name__ == "__main__":
　　 # creating thread
　　 t1 = threading.Thread(target=print_square, args=(10,))
　　 t2 = threading.Thread(target=print_cube, args=(10,))
　　 # starting thread 1
　　 t1.start()
　　 # starting thread 2
　　 t2.start()
　　 # 等到线程 1 完全执行
　　 t1.join()
　　 # 等到线程 2 完全执行
　　 t2.join()
　　 # 两个线程完全执行
　　 print("完成!")

平方: 100
立方: 1000
完成!

　　

代码解析

　　让我们试着理解上面的代码：

• 要导入线程模块，我们这样做：

import threading

• 要创建一个新线程，我们创建一个Thread类的对象。它需要以下参数：
• target : 线程要执行的函数
• args：要传递给目标函数的参数

　　在上面的示例中，我们创建了 2 个具有不同目标函数的线程：

t1 = threading.Thread(target=print_square, args=(10,)) 
　　t2 = threading.Thread(target=print_cube, args=(10,))

　　要启动一个线程，我们使用 Thread 类的 start 方法。

t1.start() 
　　t2.start()

　　一旦线程启动，当前程序（你可以把它想象成一个主线程）也会继续执行。为了在线程完成之前停止当前程序的执行，我们使用join方法。

t1.join() 
　　t2.join()

　　结果，当前程序将首先等待 t1 的完成，然后 t2 。一旦它们完成，则执行当前程序的剩余语句。

协程

　　协程（Coroutine，又称微线程，纤程）是一种比线程更加轻量级的存在，协程不是被操作系统内核所管理，而完全是由程序所控制。

　　我们都熟悉函数，也称为子例程、过程、子过程等。函数是打包为一个单元以执行特定任务的指令序列。当一个复杂函数的逻辑被分成几个独立的步骤，这些步骤本身就是函数时，这些函数被称为辅助函数或子程序。

　　Python 中的子程序由负责协调这些子程序的使用的主函数调用。子程序只有一个入口点。 协程是子程序的泛化。它们用于协作式多任务处理，其中一个进程定期或在空闲时自愿放弃（放弃）控制权，以使多个应用程序能够同时运行。协程和子程序的区别是：

• 与子程序不同，协程有许多用于暂停和恢复执行的入口点。协程可以暂停其执行并将控制权转移给其他协程，并且可以从中断点重新开始执行。
• 与子程序不同，没有主函数可以按特定顺序调用协程并协调结果。协程是协作的，这意味着它们链接在一起形成管道。一个协程可能会使用输入数据并将其发送给其他处理它的协程。最后，可能会有一个协程来显示结果。

协程与线程

　　现在您可能在想协程与线程有何不同，两者似乎都在做同样的工作。
在线程的情况下，它是根据调度程序在线程之间切换的操作系统（或运行时环境）。而在协程的情况下，决定何时切换协程的是程序员和编程语言。协程通过程序员在设定点暂停和恢复来协同工作多任务。

Python 协程

　　在 Python 中，协程类似于生成器，但几乎没有额外的方法，而且我们使用yield语句的方式也有细微的变化。生成器为迭代生成数据，而协程也可以使用数据。
在 Python 2.5 中，引入了对 yield 语句的轻微修改，现在 yield 也可以用作表达式。例如在作业的右侧——

line = (yield)

　　我们发送给协程的任何值都会被(yield)表达式捕获并返回。

　　可以通过send()方法将值发送到协程。例如，考虑这个协程，它打印出带有前缀Dear的名称。我们将使用 send() 方法将名称发送到协程。

# 用于演示协程执行的 Python3 程序
　　def print_name(prefix):
　　 print("Searching prefix:{}".format(prefix))
　　 while True:
　　 name = (yield)
　　 if prefix in name:
　　 print(name)
　　# 调用协程，什么都不会发生
　　corou = print_name("Dear")
　　# 这将开始执行协程并打印第一行 "Searching prefix..."
　　# 并将执行推进到第一个 yield 表达式
　　corou.__next__()
　　# 发送输入
　　corou.send("Haiyong")
　　corou.send("Dear Haiyong")

　　输出：

Searching prefix:Dear
Dear Haiyong

　　

协程的执行

　　协程的执行类似于生成器。当我们调用协程时，什么都没有发生，它只在响应next()和send ()方法时运行。在上面的例子中可以清楚地看到这一点，因为只有在调用__next__()方法之后，我们的协程才开始执行。在这个调用之后，执行前进到第一个 yield 表达式，现在执行暂停并等待值被发送到 corou 对象。当第一个值被发送给它时，它会检查前缀和打印名称（如果存在前缀）。打印完名称后，它会遍历循环，直到再次遇到name = (yield)表达式。

关闭协程

　　协程可能无限期运行，关闭协程使用close()方法。当协程关闭时，它会生成GeneratorExit异常，该异常可以以通常捕获的方式捕获。关闭协程后，如果我们尝试发送值，它将引发StopIteration异常。下面是一个简单的例子：

# Python3 program for demonstrating
　　# closing a coroutine
　　def print_name(prefix):
　　 print("Searching prefix:{}".format(prefix))
　　 try :
　　 while True:
　　 name = (yield)
　　 if prefix in name:
　　 print(name)
　　 except GeneratorExit:
　　 print("关闭协程！！")
　　corou = print_name("Dear")
　　corou.__next__()
　　corou.send("Haiyong")
　　corou.send("Dear Haiyong")
　　corou.close()

　　输出：

搜索前缀：Dear
Dear Haiyong
关闭协程！！

　　

链接协程以创建管道

　　协程可用于设置管道。我们可以使用 send() 方法将协程链接在一起并通过管道推送数据。管道需要：

• 初始源（生产者）派生整个管道。生产者通常不是协程，它只是一个简单的方法。
• 一个 sink，它是管道的端点。接收器可能会收集所有数据并显示它。

　　以下是一个简单的链接示例

# 用于演示协程链接的 Python 程序
　　def producer(sentence, next_coroutine):
　　 producer 只是拆分字符串并将其
　　 提供给 pattern_filter 协程
　　 tokens = sentence.split(" ")
　　 for token in tokens:
　　 next_coroutine.send(token)
　　 next_coroutine.close()
　　def pattern_filter(pattern="ing", next_coroutine=None):
　　 在接收到的令牌中搜索模式，如果模式匹配，
　　 将其发送到 print_token() 协程进行打印
　　 print("Searching for {}".format(pattern))
　　 try:
　　 while True:
　　 token = (yield)
　　 if pattern in token:
　　 next_coroutine.send(token)
　　 except GeneratorExit:
　　 print("过滤完成！！")
　　def print_token():
　　 充当接收器，只需打印接收到的令牌
　　 print("我沉了，我会打印令牌")
　　 print(token)
　　 print("打印完成！")
　　pt = print_token()
　　pt.__next__()
　　pf = pattern_filter(next_coroutine = pt)
　　pf.__next__()
　　sentence = "Haiyong is running behind a fast moving car"
　　producer(sentence, pf)

　　输出：

我沉了，我会打印令牌
Searching for ing
running
moving
过滤完成！
打印完成！

　　

总结

　　1.线程和协程推荐在 IO 密集型的任务(比如网络调用)中使用，而在CPU密集型的任务中，表现较差。
2.对于CPU密集型的任务，则需要多个进程，绕开GIL的限制，利用所有可用的CPU核心，提高效率。
3.在高并发下的最佳实践就是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

• CPU 密集型： 多进程
• IO 密集型： 多线程（协程维护成本较高,而且在读写文件方面效率没有显著提升）
• CPU 密集和 IO 密集： 多进程+协程

　　到此这篇关于Python 高级教程之线程进程和协程的代码解析的文章就介绍到这了,更多相关Python线程进程和协程内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

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