Python系列之多线程、多进程

一、python多线程

线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。

Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。

import  threading
import time

def f1(num):
    time.sleep(1)
    print("Thread-->%d" % num)

if __name__ == ‘__main__‘:
    for i in range(10):
        t = threading.Thread(target=f1,args=(i,))
        t.start()

#####output#####
Thread-->1
Thread-->0
Thread-->2
Thread-->5
Thread-->3
Thread-->6
Thread-->4
Thread-->8
Thread-->7
Thread-->9

多线程方法:

t.start() : 启动线程

t.name() : 设置获取进程名称

t.is_alive(): 检查线程是否存活

t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

t.isDaemon() ：判断是否为守护线程

t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。

t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义

t.run() ：线程被cpu调度后自动执行线程对象的run方法

线程的生命周期：

New 创建。
Runnable 就绪。等待调度
Running 运行。
Blocked 阻塞。阻塞可能在 Wait Locked Sleeping
Dead 消亡

线程中执行到阻塞，可能有3种情况：

同步：线程中获取同步锁，但是资源已经被其他线程锁定时，进入Locked状态，直到该资源可获取（获取的顺序由Lock队列控制）
睡眠：线程运行sleep()或join()方法后，线程进入Sleeping状态。区别在于sleep等待固定的时间，而join是等待子线程执行完。当然join也可以指定一个“超时时间”。从语义上来说，如果两个线程a,b, 在a中调用b.join()，相当于合并(join)成一个线程。最常见的情况是在主线程中join所有的子线程。
等待：线程中执行wait()方法后，线程进入Waiting状态，等待其他线程的通知(notify）。

线程类型：

主线程
子线程
守护线程(后台线程)
后台线程

二、线程锁threading.RLock和threading.Lock

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。看下面的例子：

num = 0
def f1(arg):
    global num
    num +=arg
    num -=arg

def f2(num):
    for i in range(100000):
        f1(num)

t1 = threading.Thread(target=f2, args=(5,))
t2 = threading.Thread(target=f2, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(num)

定义一个全局变量num 并且初始化为0，并且启动两个线程先加后减理论上应该为0 但是，由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，num的结果就不一定是0了。引入锁的概念

import threading
import time

globals_num = 0

lock = threading.RLock()

def Func():
    lock.acquire()  # 获得锁
    global globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release()  # 释放锁

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

threading.RLock和threading.Lock 的区别

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

import threading
lock = threading.Lock()    #Lock对象
lock.acquire()
lock.acquire()  #产生了死琐。
lock.release()
lock.release()

import threading
rLock = threading.RLock()  #RLock对象
rLock.acquire()
rLock.acquire()    #在同一线程内，程序不会堵塞。
rLock.release()
rLock.release()

三、Event

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False
set：将“Flag”设置为True

import  threading

def do(event):
    print(‘start‘)
    event.wait()
    print(‘execute‘)

event_obj = threading.Event()
for i in range(5): #创建5个线程并激活
    t = threading.Thread(target=do,args=(event_obj,))
    t.start()
event_obj.clear() #将“Flag”设置为False
inp = input(‘input:‘)
if inp ==‘true‘:
    event_obj.set()  #将“Flag”设置为True

四、queue

queue 就是对队列，它是线程安全的。

queue提供了一下方法：

import queue

q = queue.Queue(maxsize=0)  # 构造一个先进显出队列，maxsize指定队列长度，为0 时，表示队列长度无限制。

q.join()    # 等到队列为空的时候，在执行别的操作
q.qsize()   # 返回队列的大小 （不可靠）
q.empty()   # 当队列为空的时候，返回True 否则返回False （不可靠）
q.full()    # 当队列满的时候，返回True，否则返回False （不可靠）
q.put(item, block=True, timeout=None) #  将item放入Queue尾部，item必须存在，可以参数block默认为True,表示当队列满时，会等待队列给出可用位置，
　　　　　　　　　　　　　　　　　　　　　　　　 为False时为非阻塞，此时如果队列已满，会引发queue.Full 异常。 可选参数timeout，表示 会阻塞设置的时间，过后，
　　　　　　　　　　　　　　　　　　　　　　　　  如果队列无法给出放入item的位置，则引发 queue.Full 异常
q.get(block=True, timeout=None) #   移除并返回队列头部的一个值，可选参数block默认为True，表示获取值的时候，如果队列为空，则阻塞，为False时，不阻塞，
　　　　　　　　　　　　　　　　　　　　　　若此时队列为空，则引发 queue.Empty异常。 可选参数timeout，表示会阻塞设置的时候，过后，如果队列为空，则引发Empty异常。
q.put_nowait(item) #   等效于 put(item,block=False)
q.get_nowait() #    等效于 get(item,block=False)

五、多进程

python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing模块提供了一个Process类来代表一个进程对象

创建进程：

from multiprocessing import Process

def f(name):
    # time.sleep(3)
    print(‘hello‘,name)

if __name__ =="__main__":
    p = Process(target=f,args=(‘job‘,))
    p.start()
    p.join()  #join方法就是阻塞父进程，等待子进程执行完毕

注意：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销。

进程各自持有一份数据，默认无法共享数据如果想进行共享multiprocessing 提供两种方法Value和Array

六、进程之间的数据共享Value、Array

方法一、Value

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == ‘__main__‘:
    num = Value(‘d‘, 0.0)
    arr = Array(‘i‘, range(10))

    p = Process(target=f, args=(num, arr))
    p.start()
    p.join()

    print(num.value)
    print(arr[:])

输出：

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

创建num和arr时，“d”和“i”参数由Array模块使用的typecodes创建：“d”表示一个双精度的浮点数，“i”表示一个有符号的整数，这些共享对象将被线程安全的处理。

Array(‘i’, range(10))中的‘i’参数：

‘c’: ctypes.c_char　　　　 ‘u’: ctypes.c_wchar　　　　‘b’: ctypes.c_byte　　　　 ‘B’: ctypes.c_ubyte
‘h’: ctypes.c_short　　　  ‘H’: ctypes.c_ushort　　  ‘i’: ctypes.c_int　　　　　 ‘I’: ctypes.c_uint
‘l’: ctypes.c_long,　　　　‘L’: ctypes.c_ulong　　　　‘f’: ctypes.c_float　　　　‘d’: ctypes.c_double

方法二、Array

from multiprocessing import Process, Manager

def f(d, l):
    d[1] = ‘1‘
    d[‘2‘] = 2
    d[0.25] = None
    l.reverse()

if __name__ == ‘__main__‘:
    with Manager() as manager:
        d = manager.dict()
        l = manager.list(range(10))

        p = Process(target=f, args=(d, l))
        p.start()
        p.join()

        print(d)
        print(l)

输出：

{0.25: None, 1: ‘1‘, ‘2‘: 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

七、Pool

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

进程池中有两个方法：

apply 每一个任务是排队进行默认,进程.join()
apply_async 每一个任务都并发进行；可以设置回调函数；进程.无join()；进程daemon=True

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from  multiprocessing import Pool
import time

def Foo(i):
    time.sleep(0.5)
    return i+100

def Bar(arg):
    print(arg)

if __name__ == ‘__main__‘:
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=Foo, args=(i,),callback=Bar)
    print(‘end‘)
    pool.close()
    pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

八、协程

协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；

协程有两个模块分别为greenlet和gevent 其中greenlet为原始的模块而gevent为高级的，在greenlet的基础上进行了封装使用更为方便，可以通过pip3安装gevent也可以源码安装，需要注意安装gevent 的时候需要先安装greenlet。

1 、greenlet实例：

from greenlet import greenlet

def test1():
    print(12)
    gr2.switch()
    print (34)
    gr2.switch()

def test2():
    print (56)
    gr1.switch()
    print (78)

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()

#######output#######
12
56
34
78

2、gevent实例：

import gevent

def foo():
    print(‘12‘)
    gevent.sleep(0)
    print(‘34‘)

def bar():
    print(‘56‘)
    gevent.sleep(0)
    print(‘78‘)

gevent.joinall([
    gevent.spawn(foo),
    gevent.spawn(bar),
])

遇到IO操作自动切换：

from gevent import monkey; monkey.patch_all()
import gevent
import requests

def f(url):
    print(‘GET: %s‘ % url)
    resp = requests.get(url)
    data = resp.text
    print(‘%s bytes received from %d.‘ % (url,len(data)))

gevent.joinall([
        gevent.spawn(f, ‘https://www.python.org/‘),
        gevent.spawn(f, ‘https://www.yahoo.com/‘),
        gevent.spawn(f, ‘https://github.com/‘),
])

时间： 2024-08-11 01:35:28

Python系列之多线程、多进程

一、python多线程

二、线程锁threading.RLock和threading.Lock

threading.RLock和threading.Lock 的区别

三、Event

四、queue

五、多进程

七、Pool

八、协程

Python系列之多线程、多进程的相关文章

Python有了asyncio和aiohttp在爬虫这类型IO任务中多线程/多进程还有存在的必要吗？

python-学习-python并发编程之多进程与多线程

关于Python和Java的多进程多线程计算方法对比

python分别使用多线程和多进程获取所有股票实时数据

<转载> 为什么在Python里推荐使用多进程而不是多线程？

Python进阶 - 多线程多进程基础

Python多线程多进程那些事儿看这篇就够了~~

Python系列教程大汇总

Python 3 并发编程多进程之队列（推荐使用）