Python 多线程应用

同步锁

import time

import threading

def subNum():

    global num

    # print("ok")

    lock.acquire()  # 加锁

    temp = num

    time.sleep(1)

    num = temp - 1  # 加在公共数据上

    lock.release()  # 解锁

num = 100

thread_list = []

lock = threading.Lock()

for i in range(100):

    t = threading.Thread(target=subNum)

    t.start()

    thread_list.append(t)

for t in thread_list:

    t.join()

print("ressult", num)

死锁与递归锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

import threading

import time

mutexA = threading.Lock()

mutexB = threading.Lock()

class MyThread(threading.Thread):

    def __init__(self):

        threading.Thread.__init__(self)

    def run(self):

        self.fun1()

        self.fun2()

    def fun1(self):

        mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))

        mutexB.acquire()

        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))

        mutexB.release()

        mutexA.release()

    def fun2(self):

        mutexB.acquire()

        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))

        time.sleep(0.2)

        mutexA.acquire()

        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))

        mutexA.release()

        mutexB.release()

if __name__ == "__main__":

    print("start---------------------------%s"%time.time())

    for i in range(0, 10):

        my_thread = MyThread()

        my_thread.start()

在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

Event对象

event.isSet()：返回event的状态值；

event.wait()：如果 event.isSet()==False将阻塞线程；

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

event.clear()：恢复event的状态值为False。

可以考虑一种应用场景（仅仅作为说明），例如，我们有多个线程从Redis队列中读取数据来处理，这些线程都要尝试去连接Redis的服务，一般情况下，如果Redis连接不成功，在各个线程的代码中，都会去尝试重新连接。如果我们想要在启动时确保Redis服务正常，才让那些工作线程去连接Redis服务器，那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作：主线程中会去尝试连接Redis服务，如果正常的话，触发事件，各工作线程会尝试连接Redis服务。

import threading

import time

import logging

logging.basicConfig(level=logging.DEBUG, format='(%(threadName)-10s) %(message)s',)

def worker(event):

    logging.debug('Waiting for redis ready...')

    event.wait()

    logging.debug('redis ready, and connect to redis server and do some work [%s]', time.ctime())

    time.sleep(1)

def main():

    readis_ready = threading.Event()

    t1 = threading.Thread(target=worker, args=(readis_ready,), name='t1')

    t1.start()

    t2 = threading.Thread(target=worker, args=(readis_ready,), name='t2')

    t2.start()

    logging.debug('first of all, check redis server, make sure it is OK, and then trigger the redis ready event')

    time.sleep(3) # simulate the check progress

    readis_ready.set()

if __name__=="__main__":

    main()

threading.Event的wait方法还接受一个超时参数，默认情况下如果事件一致没有发生，wait方法会一直阻塞下去，而加入这个超时参数之后，如果阻塞时间超过这个参数设定的值之后，wait方法会返回。对应于上面的应用场景，如果Redis服务器一致没有启动，我们希望子线程能够打印一些日志来不断地提醒我们当前没有一个可以连接的Redis服务，我们就可以通过设置这个超时参数来达成这样的目的：

Semphore(信号量)

emaphore管理一个内置的计数器，

每当调用acquire()时内置计数器-1；

调用release() 时内置计数器+1；

计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

import threading

import time

semaphore = threading.Semaphore(5)  # 设置最大连接数是5

def func():

    if semaphore.acquire():

        print (threading.currentThread().getName() + ' get semaphore')

        time.sleep(2)

        semaphore.release()

for i in range(20):

  t1 = threading.Thread(target=func)

  t1.start()

这个的应用是连接池

multiprocessing模块多进程模块

由于GIL的存在，python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。

multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部份与threading使用同一套API，只不过换到了多进程的情境。

python的进程调用

from multiprocessing import Process

import os

import time

def info(name):

    print("name:",name)

    print('parent process:', os.getppid())

    print('process id:', os.getpid())

    print("------------------")

    time.sleep(1)

def foo(name):

    info(name)

if __name__ == '__main__':

    info('main process line')

    p1 = Process(target=info, args=('alvin',))

    p2 = Process(target=foo, args=('egon',))

    p1.start()

    p2.start()

    p1.join()

    p2.join()

    print("ending")

协程

import time

"""

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

"""

# 注意到consumer函数是一个generator（生成器）:

# 任何包含yield关键字的函数都会自动成为生成器(generator)对象

def consumer():

    r = ''

    while True:

        # 3、consumer通过yield拿到消息，处理，又通过yield把结果传回；

        #    yield指令具有return关键字的作用。然后函数的堆栈会自动冻结(freeze)在这一行。

        #    当函数调用者的下一次利用next()或generator.send()或for-in来再次调用该函数时，

        #    就会从yield代码的下一行开始，继续执行，再返回下一次迭代结果。通过这种方式，迭代器可以实现无限序列和惰性求值。

        n = yield r

        if not n:

            return

        print('[CONSUMER] ←← Consuming %s...' % n)

        time.sleep(1)

        r = '200 OK'

def produce(c):

    # 1、首先调用c.next()启动生成器

    next(c)

    n = 0

    while n < 5:

        n = n + 1

        print('[PRODUCER] →→ Producing %s...' % n)

        # 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行；

        cr = c.send(n)

        # 4、produce拿到consumer处理的结果，继续生产下一条消息；

        print('[PRODUCER] Consumer return: %s' % cr)

    # 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

    c.close()

if __name__=='__main__':

    # 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

    c = consumer()

    produce(c)

'''

result:

[PRODUCER] →→ Producing 1...

[CONSUMER] ←← Consuming 1...

[PRODUCER] Consumer return: 200 OK

[PRODUCER] →→ Producing 2...

[CONSUMER] ←← Consuming 2...

[PRODUCER] Consumer return: 200 OK

[PRODUCER] →→ Producing 3...

[CONSUMER] ←← Consuming 3...

[PRODUCER] Consumer return: 200 OK

[PRODUCER] →→ Producing 4...

[CONSUMER] ←← Consuming 4...

[PRODUCER] Consumer return: 200 OK

[PRODUCER] →→ Producing 5...

[CONSUMER] ←← Consuming 5...

[PRODUCER] Consumer return: 200 OK

'''

greentlet

greelet机制的主要思想是：生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库.

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()

基于greenlet的框架

Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持

gevent是第三方库，通过greenlet实现协程

import gevent

import time

def foo():

    print("running in foo")

    gevent.sleep(2)

    print("switch to foo again")

def bar():

    print("switch to bar")

    gevent.sleep(5)

    print("switch to bar again")

start=time.time()

gevent.joinall(

    [gevent.spawn(foo),

    gevent.spawn(bar)]

)

print(time.time()-start)