python使用多线程（二）

介绍

1、多线程

其实python在同一时间只允许一个线程执行一个任务，其它线程都会被锁住。多线程其实就是不停的线程切换，给人以多线程的现象。python中实现这个功能的结构称为全局解释器锁（GIL）。

如果任务都是相同的，比如一直执行total=total+1，这时其实多线程帮不了太多忙，即使单线程也可以完成这个工作，因为单线程在处理这个操作的时候，基本上没有阻碍和停滞。不像上次举的汽车装配的例子，当其中一个工位被占用的时候，这时多线程可以执行另外两个操作，从而加快整体的速度。

如果遇到这种情况，可以考虑多核操作。每个核有单独的逻辑空间，不同核内可以在相同时间同时运行一个线程。

2、多进程

进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身；用户进程就不必我多讲了吧，所有由你启动的进程都是用户进程。进程是操作系统进行资源分配的单位。

在Windows下，进程又被细化为线程，也就是一个进程下有多个能独立运行的更小的单位。

在同一个时间里，同一个计算机系统中如果允许两个或两个以上的进程处于运行状态，这便是多任务。现代的操作系统几乎都是多任务操作系统，能够同时管理多个进程的运行。多任务带来的好处是明显的，比如你可以边听mp3边上网，与此同时甚至可以将下载的文档打印出来，而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题，俗话说，一心不能二用，这对计算机也一样，原则上一个CPU只能分配给一个进程，以便运行这个进程。我们通常使用的计算机中只有一个CPU，也就是说只有一颗心，要让它一心多用，同时运行多个进程，就必须使用并发技术。实现并发技术相当复杂，最容易理解的是“时间片轮转进程调度算法”，它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来CPU是在轮流为多个进程服务，就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。

如果一台计算机有多个CPU，情况就不同了，如果进程数小于CPU数，则不同的进程可以分配给不同的CPU来运行，这样，多个进程就是真正同时运行的，这便是并行。但如果进程数大于CPU数，则仍然需要使用并发技术。

Python中多线程之lock（）

这是锁的概念，首先直观的看下没有锁的状态：

import threadingdef job1():global Afor i in range(10):A+=4print('job1',A)def job2():global Afor i in range(10):A+=10print('job2',A)if __name__=='__main__':A=0t1=threading.Thread(target=job1)t2 = threading.Thread(target=job2)t1.start()t2.start()t1.join()t2.join()

输出结果：

job1 4
job1 8
job1 12
job1 16
job1 20
job1 24
job2 34
job1 38
job2 48
job1 52
job2 62
job1 66
job2 76
job1 80
job2 90
job2 100
job2 110
job2 120
job2 130
job2 140

从结果上可以看出，输出的比较乱，这是因为在t1没有计算完成时，t2也开始了计算，这就导致输出比较乱，有交叉和重叠。

加上锁之后：

import threadingdef job1():global A,locklock.acquire()for i in range(10):A+=4print('job1',A)lock.release()def job2():global A,locklock.acquire()for i in range(10):A+=10print('job2',A)lock.release()if __name__=='__main__':lock=threading.Lock()A=0t1=threading.Thread(target=job1)t2 = threading.Thread(target=job2)t1.start()t2.start()t1.join()t2.join()

输出结果：

job1 4
job1 8
job1 12
job1 16
job1 20
job1 24
job1 28
job1 32
job1 36
job1 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110
job2 120
job2 130
job2 140

可以看出job1和job2之间互不干涉，这是因为lock可以锁住线程，基本思想就是，在执行完job1之前，该线程不会去执行其它操作，只会执行job1，当job1完成后开始解锁，这个时候线程才会去执行job2，最终输出的是有序的数据。

死锁和递归锁RLock

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

from threading import Thread,RLock,Lock
import time
# mutexA=Lock()
# mutexB=Lock()
mutexA=mutexB=RLock()  #RLock锁可以解决死锁问题，只要锁的引用计数为0，大家就都可以抢了
class MyThread(Thread):def run(self):self.f1()self.f2()def f1(self):mutexA.acquire() #1print('%s 拿到了A锁' %self.name)mutexB.acquire() #2print('%s 拿到了B锁' %self.name)mutexB.release() # 1mutexA.release() # 0#此时引用计数都是0了，第一个线程也会跟着其他的线程一起去抢才能抢到锁def f2(self):mutexB.acquire()print('%s 拿到了B锁' %self.name)time.sleep(0.1)mutexA.acquire()print('%s 拿到了A锁' %self.name)mutexA.release()mutexB.release()if __name__=='__main__':for i in range(10):t=MyThread()t.start()

线程池ThreadPoolExecutor

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import requests
import timedef get(url):print('%s get %s' %(current_thread().getName(),url))response=requests.get(url)time.sleep(2)if response.status_code==200:return {'url':url,'content':response.text}def parse(res):res=res.result()print('parse:[%s] res:[%s]' %(res['url'],len(res['content'])))if __name__ == '__main__':pool=ThreadPoolExecutor(2)urls=['https://www.baidu.com','https://www.python.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org','https://www.openstack.org',]for url in urls:pool.submit(get,url).add_done_callback(parse)pool.shutdown(wait=True)

更多内容请参考：https://blog.csdn.net/qq_34857250/article/details/79314201#多进程