python多线程的多种实现方式

python多线程的多种实现方式

由于多线程是一种并发执行，所以需要先搞清楚并发和并行间的区别；想象一下现在你在吃晚餐，这是你的对象突然给你打电话，那么在这个过程中，什么时候是并发，什么时候又是并行呢？

• 并发：吃饭的时候电话响了，你接起了电话，打完电话后继续吃饭
• 并行：边吃饭边打电话，这里需要注意的是，只有在你吃饭的时候你对象在说话时候才是并行；如果是边吃饭边说话，这只能算并发，因为嚼食物和说话没有办法同时进行。

所以，总结一下，并行强调的是同一时间做多件事情，每件事情间没有先后顺序；并发强调的则是同一时刻（同一区间内）做多件事情，但实际上每件事情间有先后顺序，只是操作系统太快了，让我们忽略了事情间的先后顺序。

这时候问题又出现了，为什么要实现并发，并发有什么好处呢？
主要可以总结为以下几点：

• 在真实的工作场景中，很多电脑是有多核CPU的计算能力,利用并发可以极大提升应用性能；
• 复杂的操作可以分成多个进程（或线程）同时进行，降低处理时间；
• 无限复用一些功能函数，使得程序设计在某些情况下更简单，利用重写实现更多的个性化操作
• 学过操作系统的同学都知道，IO的速度是很慢的，但CPU的速度很快，如果让CPU一直等待IO很浪费时间
  当然，硬币有两面，并发也不例外，它的缺点是
• 频繁的上下文切换会损耗性能（相比于进程间的切换，线程切换更加便利）；可以用不同的线程处理不同段的数据/乐观锁减少一部分不必要的锁竞争带来的上下文切换/单线程里实现多任务的调度等方法来进行优化
• 编写代码不注意的话容易产生死锁；可以用一个线程一个锁/一个线程一个资源/定时锁/数据库锁等方法来进行优化。

python有threading函数可以用来实现并发，该函数提供了如下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

下面介绍不同的实现并发的写法。

函数方式写法

import threading
from threading import Lock,Thread
import time,os

def run(n):
    print('task',n)
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')
    time.sleep(1)
    print('0s')
    time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=run,args=('t1',))     
    # target:要执行的函数名，args:函数对应的参数，以元组的形式存在
    t2 = threading.Thread(target=run,args=('t2',))
    t1.start()
    t2.start()

继承方式写法

class MyThread(threading.Thread):
    def __init__(self,n):
        super(MyThread,self).__init__() 
        self.n = n

    def run(self):
        print('task',self.n)
        time.sleep(1)
        print('2s')
        time.sleep(1)
        print('1s')
        time.sleep(1)
        print('0s')
        time.sleep(1)

if __name__ == '__main__':
    t1 = MyThread('t1')
    t2 = MyThread('t2')
    t1.start()
    t2.start()

下一个概念，守护线程，通俗来说就是主线程结束后，无论子线程是否执行完毕都立马结束，这样能保证主线程永远是可以执行完成的，而不用等待所有子线程执行完毕才完成。talk is cheap，看代码吧。

def run(n):
    print('task',n)
    time.sleep(1)
    print('3s')
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')

if __name__ == '__main__':
    t=threading.Thread(target=run,args=('t1',))
    t.setDaemon(True)
    #这一步就是设定守护线程
    t.start()
    print('end')

从执行结果可以看出，在打印完task t1之后就直接打印end了，不会继续执行打印3s、2s、1s的操作。
同样地，设定守护线程的好处在于保证主线程的成功结束，真实工作环境中的需求会更加复杂，有时候又需要确定子线程执行结束后，主线程再结束，此时只需要加个join就可以。代码如下：

def run(n):
    print('task',n)
    time.sleep(2)
    print('5s')
    time.sleep(2)
    print('3s')
    time.sleep(2)
    print('1s')
if __name__ == '__main__':
    t=threading.Thread(target=run,args=('t1',))
    t.setDaemon(True)    
    #把子线程设置为守护线程，必须在start()之前设置
    t.start()
    t.join()     #设置主线程等待子线程结束
    print('end')

保证线程安全之互斥锁

def work():
    global n
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp-1
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

• 其他还有递归锁，信号量等方法，代码相对复杂，就不贴了

那么什么时候用python多线程？先来分析python对不同类型的代码执行效率对比：

• CPU密集型代码（各种循环处理、计算等），在这种情况下，由于计算工作多，ticks技术很快就会达到阀值，触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。
• IO密集型代码（文件处理、网络爬虫等设计文件读写操作），多线程能够有效提升效率（单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序的执行效率）。

多线程在切换中又分为I/O切换和时间切换。如果任务属于是I/O密集型，若不采用多线程，我们在进行I/O操作时，势必要等待前面一个I/O任务完成后面的I/O任务才能进行，在这个等待的过程中，CPU处于等待状态，这时如果采用多线程的话，刚好可以切换到进行另一个I/O任务。这样就刚好可以充分利用CPU避免CPU处于闲置状态，提高效率。
但是如果多线程任务都是计算型，CPU会一直在进行工作，直到一定的时间后采取多线程时间切换的方式进行切换线程，此时CPU一直处于工作状态，此种情况下并不能提高性能，相反在切换多线程任务时，可能还会造成时间和资源的浪费，导致效能下降。这就是造成上面两种多线程结果不能的解释。

• 结论:I/O密集型任务建议采取多线程，还可以采用多进程+协程的方式(例如:爬虫多采用多线程处理爬取的数据)；对于计算密集型任务，python则不适用。