来自 计算机编程 2019-12-09 01:12 的文章
当前位置: 澳门威尼斯人平台 > 计算机编程 > 正文

python系列7进程线程和协程,python线程和协程

    我们大多数的时候使用多线程,以及多进程,但是python中由于GIL全局解释器锁的原因,python的多线程并没有真的实现

1、进程的概念

什么是进程—>CPU在同一时刻只能处理一个任务,只是因为cpu执行速度很快。
cpu在各个任务之间来回的进行切换。
进程的概念:正在进行的一个过程或者说一个任务,而负责执行任务的则是CPU,进程本身是
一个抽象的概念,即进程就是一个过程、一个任务。
CPU描述的是一个程序的执行过程.
进程之间是如何做到并发的:CPU在各个任务之间来回的进行切换,并在切换的过程当中保存当前
进程的执行状态(保存蛋糕的执行过程)。
进程与程序的区别:程序相当于菜谱,而进程相当于做菜的整个过程。
需要强调的是:同一个程序执行两次(双击),那也是两个进程,比如打开暴风影音,虽然都是同一个软件,但是一个可以播放a,一个可以播放b.
核的概念:
处理器,就是说有几个处理器。。。也就说一个CPU里面会有几个处理器,这样就可以同时处理几个要求了。。。

python 线程,进程与协程,python线程协程

 引言

线程

  创建普通多线程

线程锁

  互斥锁

  信号量

  事件

  条件锁

  定时器

  全局解释器锁

队列

  Queue:先进先出队列

  LifoQueue:后进先出队列

  PriorityQueue:优先级队列

  deque:双向队列

 

python系列7进程线程和协程,python线程和协程

      实际上,python在执行多线程的时候,是通过GIL锁,进行上下文切换线程执行,每次真实只有一个线程在运行。所以上边才说,没有真的实现多现程。

2、并行与并发的区别

无论是并行还是并发,在用户看来都是同时运行的,不管是进程还是线程,都只是一个任务而已,
真正干活的是CPU,CPU来做这些任务,而一个cpu(单核)同一时刻只能执行一个任务。
并行:多个任务同时运行,只有具备多个cpu才能实现并行,含有几个cpu,也就意味着在同一时刻可以执行几个任务。
并发:是伪并行,即看起来是同时运行的,实际上是单个CPU在多道程序之间来回的进行切换。

引言

在学习过socket和socketserver后,我们了解到socketserver可以支持IO多路复用。在定义socketserver服务端的时候一般会使用:

server = socketserver.ThreadingTCPServer(settings.IP_PORT, MyServer)

ThreadingTCPServer这个类便是可以支持多线程和TCP协议的socketserver模块。读源码的时候可以发现其继承关系:

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

  右边的TCPServer实际上是它主要的功能父类,而左边的ThreadingMixIn则是实现了多线程的类,它自己本身则没有任何代码。MixIn在python的类命名中,很常见,一般被称为“混入”,戏称“乱入”,通常为了某种重要功能被子类继承。

class ThreadingMixIn:

    daemon_threads = False

    def process_request_thread(self, request, client_address):      
        try:
            self.finish_request(request, client_address)
            self.shutdown_request(request)
        except:
            self.handle_error(request, client_address)
            self.shutdown_request(request)

    def process_request(self, request, client_address):

        t = threading.Thread(target = self.process_request_thread,
                             args = (request, client_address))
        t.daemon = self.daemon_threads
        t.start()

目录

  进程

  线程

  协程

    上下文切换

 

      那么python的多线程就没有什么用了吗?

3、同步与异步的概念

同步就是指一个进程在执行某个请求的时候,若该请求需要一段时间才能返回信息,那么这个进程将会一直等待下去,直到收到返回信息才继续执行下去。
异步是指进程不需要一直等下去,而是继续执行下面的操作,不管其他进程的状态。当有消息返回时系统会通知进行处理,这样可以提高执行的效率。
打电话的过程就是同步通信,发短信时就是异步通信。

一、线程:

线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。另外,线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不独立拥有系统资源,但它可与同属一个进程的其它线程共享该进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件,逻辑上可以运行,在等待处理机;运行状态是指线程占有处理机正在运行;阻塞状态是指线程在等待一个事件(如某个信号量),逻辑上不可执行。每一个应用程序都至少有一个进程和一个线程。线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的被划分成一块一块的工作,称为多线程。         好比一个工厂中分为多个厂房,每个厂房中又有若干条生产线。每条生产线生产特定的产品,再由工厂组装起来统一发货(输出)。每个工厂就相当于一个进程,每条生产线相当于一个线程。   普通多线程 通过threading模块,可以轻易的在当前进程中创建多个线程。

import threading
import time

def show(arg):
    time.sleep(1)
    print('thread'+str(arg))

for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()

print('main thread stop')

上述代码创建了10个“前台”线程,然后控制器就交给了CPU,CPU根据指定算法进行调度,分片执行指令。 下面是Thread类的主要方法:   start 线程准备就绪,等待CPU调度 setName 为线程设置名称 getName 获取线程名称 setDaemon 设置为后台线程或前台线程(默认) 如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止。如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止。 join 逐个执行每个线程,执行完毕后继续往下执行,该方法使得多线程变得无意义。 run 线程被cpu调度后自动执行线程对象的run方法 

 

自定义线程类: 通过阅读源码,可以发现threading模块中的Thread类,本质上是执行了它的run方法,可以自定义线程类,继承Tread类,然后重写run方法。 图片 1import threading class MyThread(threading.Thread): def __init__(self,func,args): self.func = func self.args = args super(MyThread,self).__init__() #继承父类构造方法 def run(self): self.func(self.args) def f2(arg): print(arg) obj = MyThread(f2,123) obj.start() 自定义线程类 线程锁 由于线程之间是进行随机调度,并且每个线程可能只执行n条执行之后,当多个线程同时修改同一条数据时可能会出现脏数据,所以,出现了线程锁

  • 同一时刻允许一个线程执行操作。 未使用锁:

    #!/usr/bin/env python # * coding:utf8 *_ import threading import time NUM = 0 def f1():

      global NUM
      NUM+=1
      name = t.getName()
      time.sleep(1)
      print(name,'执行结果',NUM)
    

    for i in range(10):

      t = threading.Thread(target=f1)
      t.start()
    

    #f1作为子线程执行,由于存在time.sleep(1),当主进程执行完毕之后,子线程才开始执行。导致结果出错。 print('执行结束')

  执行结果:

执行结束
Thread-1 执行结果 10
Thread-4 执行结果 10
Thread-3 执行结果 10
Thread-5 执行结果 10
Thread-2 执行结果 10
Thread-6 执行结果 10
Thread-8 执行结果 10
Thread-7 执行结果 10
Thread-10 执行结果 10
Thread-9 执行结果 10

  

 由于线程共用同一进程的资源,当主进程执行完之后再执行子线程时,产生了脏数据,因为主进程在for循环中已经从0-9赋值一遍。而子线程sleep 1 s后才开执行。这时得到的结果是循环10次后的结果。 为了解决这个问题,python在threading模块中定义了几种线程锁类,分别是: 

  • Lock 普通锁(不可嵌套)
  • RLock 普通锁(可嵌套)常用
  • Semaphore 信号量
  • event 事件
  • condition 条件

线程锁(Lock,RLock) 线程锁也叫互斥锁,是独占的,同一时刻只有一个线程被放行。 图片 2import threading import time NUM = 0 def f1(i,lock): global NUM name = t.getName()#t是定义的线程,将这句代码放在线程锁之后会导致无法获取正确的线程名 lock.acquire() #定义锁作用空间的起始位置 NUM+=1 #name = threading.current_thread().name #等效于getName,不过输出的是每次执行的线程名 time.sleep(1) print(name,i,'执行结果',NUM) lock.release() #释放锁 lock = threading.RLock() #lock = threading.Lock() for i in range(30): t = threading.Thread(target=f1,args=(i,lock,)) t.start() #f1作为子线程执行,由于存在time.sleep(1),当主进程执行完毕之后,子线程才开始执行。如果不使用线程锁的话结果出错。 print('执行结束') 线程锁 以上是threading模块的Lock类,它不支持嵌套锁。RLcok类的用法和Lock一模一样,但它支持嵌套,因此我们一般直接使用RLcok类。 信号量(Semaphore) 信号量根据设定的数值一次放行相应的数量的线程,它不是互斥锁。比如地铁安检,一次只能放行一定数量的人,剩下的继续排队等候。 图片 3import threading import time NUM = 0 def f1(i,lock): global NUM name = t.getName() lock.acquire() #定义锁作用空间的起始位置 NUM+=1 name = t.getName() time.sleep(1) print(name,i,'执行结果',NUM) lock.release() #释放锁 lock = threading.BoundedSemaphore(5) for i in range(30): t = threading.Thread(target=f1,args=(i,lock,)) t.start() print('执行结束') 信号量 事件(Event) 类名:Event 事件主要提供了三个方法 set、wait、clear。 事件机制:全局定义了一个“Flag”,如果“Flag”的值为False,那么当程序执行wait方法时就会阻塞,如果“Flag”值为True,那么wait方法时便不再阻塞(wait默认为阻塞状态)。这种锁,类似交通红绿灯(默认是红灯),它属于在红灯的时候一次性阻挡所有线程,在绿灯的时候,一次性放行所有的排队中的线程。 clear:将“Flag”设置为False set:将“Flag”设置为True 图片 4import threading def func(e,i): print(i) e.wait() #检测当前event是什么状态,如果是红灯,则阻塞,绿灯则放行。默认为红灯。 print(i+100) event = threading.Event() for i in range(10): t = threading.Thread(target=func,args=(event,i)) t.start() event.clear() #将状态设置为红灯。 inp = input('>>> ') if inp.strip() =='b': event.set() #将状态设置为绿灯 事件 条件锁(condition) 条件锁会让线程等待直到满足条件是才释放进程 图片 5import threading def condiction(): ret = False inp = input('>>> ') if inp == 'y': ret = True return ret def func(cond,i): print(i) cond.acquire() cond.wait_for(condiction) #接受函数condition的返回值,Wait until a condition evaluates to True print(i+100) cond.release() c=threading.Condition() for i in range(10): t = threading.Thread(target=func,args=(c,i)) t.start() 条件锁1

上面的例子每次只会释放一个线程。

图片 6import threading def run(n): con.acquire() con.wait() #Wait until notified or until a timeout occurs print('run this threading %s'%n) con.release() if __name__ == '__main__': con= threading.Condition() for i in range(10): t = threading.Thread(target=run,args=(i,)) t.start() while True: inp = input('>>> ') if inp =='q': break con.acquire() con.notify(int(inp)) #根据条件唤醒一个到多个线程,如果线程之前没有处于acquire的Lock状态,则报错 #RuntimeError: cannot notify on un-acquired lock con.release() 条件锁2 定时器(Timer) 指定程序在多长时间后执行某项操作 图片 7from threading import Timer def hello(): print('hello') t=Timer(1,hello) #延迟1s后执行 t.start() 定时器 全局解释器锁GIL(摘自刘江大哥博客)

既然介绍了多线程和线程锁,那就不得不提及python的GIL,也就是全局解释器锁。在编程语言的世界,python因为GIL的问题广受诟病,因为它在解释器的层面限制了程序在同一时间只有一个线程被CPU实际执行,而不管你的程序里实际开了多少条线程。所以我们经常能发现,python中的多线程编程有时候效率还不如单线程,就是因为这个原因。那么,对于这个GIL,一些普遍的问题如下:

  • 每种编程语言都有GIL吗?

    以python官方Cpython解释器为代表....其他语言好像未见。
    
  • 为什么要有GIL?

    作为解释型语言,Python的解释器必须做到既安全又高效。我们都知道多线程编程会遇到的问题。解释器要留意的是避免在不同的线程操作内部共享的数据。同时它还要保证在管理用户线程时总是有最大化的计算资源。那么,不同线程同时访问时,数据的保护机制是怎样的呢?答案是解释器全局锁GIL。GIL对诸如当前线程状态和为垃圾回收而用的堆分配对象这样的东西的访问提供着保护。
    
  • 为什么不能去掉GIL?

    首先,在早期的python解释器依赖较多的全局状态,传承下来,使得想要移除当今的GIL变得更加困难。其次,对于程序员而言,仅仅是想要理解它的实现就需要对操作系统设计、多线程编程、C语言、解释器设计和CPython解释器的实现有着非常彻底的理解。
    在1999年,针对Python1.5,一个“freethreading”补丁已经尝试移除GIL,用细粒度的锁来代替。然而,GIL的移除给单线程程序的执行速度带来了一定的负面影响。当用单线程执行时,速度大约降低了40%。虽然使用两个线程时在速度上得到了提高,但这个提高并没有随着核数的增加而线性增长。因此这个补丁没有被采纳。
    另外,在python的不同解释器实现中,如PyPy就移除了GIL,其执行速度更快(不单单是去除GIL的原因)。然而,我们通常使用的CPython占有着统治地位的使用量,所以,你懂的。
    在Python 3.2中实现了一个新的GIL,并且带着一些积极的结果。这是自1992年以来,GIL的一次最主要改变。旧的GIL通过对Python指令进行计数来确定何时放弃GIL。在新的GIL实现中,用一个固定的超时时间来指示当前的线程以放弃这个锁。在当前线程保持这个锁,且当第二个线程请求这个锁的时候,当前线程就会在5ms后被强制释放掉这个锁(这就是说,当前线程每5ms就要检查其是否需要释放这个锁)。当任务是可行的时候,这会使得线程间的切换更加可预测。
    
  • GIL对我们有什么影响?

    最大的影响是我们不能随意使用多线程。要区分任务场景。
    在单核cpu情况下对性能的影响可以忽略不计,多线程多进程都差不多。在多核CPU时,多线程效率较低。GIL对单进程和多进程没有影响。
    
  • 在实际使用中有什么好的建议?

    建议在IO密集型任务中使用多线程,在计算密集型任务中使用多进程。深入研究python的协程机制,你会有惊喜的。
    来源: http://www.cnblogs.com/feixuelove1009/p/5683159.html
    

关于GIL,发现一个比较有意思的文章 二、队列 队列是一种规整的数据结构,和后进先出的堆栈不同,队列是一种先进先出的结构,就像一根管子,最先进去的数据也最先被得到。但是在Python中,提供一个queue模块,不仅可以实现普通队列,还提供几种特殊的队列。

  • queue.Queue :先进先出队列
  • queue.LifoQueue :后进先出队列
  • queue.PriorityQueue :优先级队列
  • queue.deque :双向队列

Queue:先进先出队列 图片 8import queue q = queue.Queue(5)#定义最大元素个数 q.put(11) q.put(22) q.put(33) print(q.get()) print(q.get()) print(q.get()) Queue Queue类的方法:

  • maxsize 队列的最大元素个数,也就是queue.Queue(5)中的5。当队列内的元素达到这个值时,后来的元素默认会阻塞,等待队列腾出位置。

    def __init__(self, maxsize=0):self.maxsize = maxsize
    self._init(maxsize)
    
  • qsize() 获取当前队列中元素的个数,也就是队列的大小

  • empty() 判断当前队列是否为空,返回True或者False
  • full() 判断当前队列是否已满,返回True或者False
  • put(self, block=True, timeout=None)

    往队列里放一个元素,默认是阻塞和无时间限制的。如果,block设置为False,则不阻塞,这时,如果队列是满的,放不进去,就会弹出异常。如果timeout设置为n秒,则会等待这个秒数后才put,如果put不进去则弹出异常。
    
  • get(self, block=True, timeout=None)
    从队列里获取一个元素。参数和put是一样的意思。

  • join() 阻塞进程,直到所有任务完成,需要配合另一个方法task_done。

    def join(self):with self.all_tasks_done:
            while self.unfinished_tasks:
                self.all_tasks_done.wait()
    

      

  • task_done() 表示某个任务完成。每一条get语句后需要一条task_done。

    import queue
    q = queue.Queue(5)
    q.put(11)
    q.put(22)
    print(q.get())
    q.task_done()
    print(q.get())
    q.task_done()
    q.join()  
    

LifoQueue:后进先出队列 图片 9import queue q = queue.LifoQueue() q.put(123) q.put(456) print(q.get()) LifoQueue PriorityQueue:优先级队列 每个元素都是一个元组,第一位表示优先级,数字越小优先级越高。同样优先级则先进先出 图片 10q = queue.PriorityQueue() q.put((1,"zhang1")) q.put((1,"zhang2")) q.put((1,"zhang3")) q.put((3,"zhang3")) print(q.get()) PriorityQueue deque:双向队列 双向队列两个方向都可以进出,取数时也可以两个方向取,注意pop是从右开始取数,popleft从左开始取数 图片 11q = queue.deque() q.append(11) q.append(22) q.appendleft(33) q.appendleft(44) print(q.popleft()) print(q.popleft()) print(q.pop()) print(q.pop()) q.append(55) deque

 

  

线程,进程与协程,python线程协程 引言 线程 创建普通多线程 线程锁 互斥锁 信号量 事件 条件锁 定时器 全局解释器锁 队列 Queue:先...

前言:线程和进程的关系图

  由下图可知,在每个应用程序执行的过程中,都会去产生一个主进程和主线程来完成工作,当我们需要并发的执行的时候,就会通过主进程去生成一系列的子进程(然后通过子进程产生一系列的子线程)来使不同的cpu调用,从而达到并发的效果。但是需要注意的是,在一般情况下每个进程之间是相互独立的。

  GIL全局解释器锁在Python中是独有的,java和c#中都没有,他的作用主要是什么呢?我们都知道程序的执行最小单元是线程,在cpu1通过进程来调用线程的时候(只是在cpu调用的时候),只能轮询的去调用某个进程中的线程,线程并不能进行并发的执行,也就是说一个时刻每颗cpu只能通过一个进程中的一个线程来完成某项工作。

  在我们一般的程序中,如果没有特意的创建进程和线程,那么我们程序就是按照顺序一步一步执行的,当我们创建了进程和线程之后,就会产生并发执行的效果。

              不是这个样子的,python多线程一般用于IO密集型的程序,那么什么叫做IO密集型呢,举个例子,比如说带有阻塞的。当前线程阻塞等待其它线程执行。

4、进程创建的方式

用户创建出来的所有进程都是由操作系统负责的,因此无论是哪一种创建进程的方式,实际上都是调用操作系统的接口创建的,进程的切换都是由操作系统控制的。
无论哪一种创建进程的方式,新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的。

  进程

    优点: 可同时利用多个cpu,进行多个操作

    缺点: 重新开辟内存空间,非常耗费资源

    个数: 一般和cpu颗数相同

    使用场所: 一般是计算密集型

      即然说到适合python多线程的,那么什么样的不适合用python多线程呢?

5、父进程和子进程之间的关系

子进程创建后,父进程和子进程有各自不同的地址空间,多道技术要求物理层面实现进程之间内存的
隔离,任何一个进程在其地址空间的修改都不会影响到另外一个进程。
注意:子进程和父进程之间是可以有只读的共享的内存区域的。
进程与进程之间数据(资源)是隔离的,两个进程之间可以基于管道这种方式进行通信。在Unix当中,是含有进程层次的概念的,但是在windows当中,是没有进程层次的概念的,所有的进程都是地位相同的。
在Linux当中,每启动一个命令,都会启动一个进程。

  线程

    优点: 共享内存(一个进程内),i/o操作可实现并发执行

    缺点: 抢占资源,切换上下文非常耗时

      个数: 一般依情况而定

    使用场所: i/o密集型

 图片 12

              答案是CPU密集型的,那么什么样的是CPU密集型的呢?百度一下你就知道。

6、线程的概念

一个进程里面至少有一个控制线程,进程的概念只是一种抽象的概念,真正在CPU上面调度的是进程
里面的线程,就好比真正在地铁这个进程里面工作的实际上是地铁里面的线程,北京地铁里面至少要有
一个线程,线程是真正干活的,线程用的是进程里面包含的一堆资源,线程仅仅是一个调度单位,不包含资源。

一.进程

本文由澳门威尼斯人平台发布于计算机编程,转载请注明出处:python系列7进程线程和协程,python线程和协程

关键词: