第三部分：Semaphore控制进入数量的锁
有时候可能需要运行多个工作线程同时访问一个资源，但要限制总数。例如，连接池支持同时连接，但是数目可能是固定的，或者一个网络应用可能支持固定数据的并发下载。这些连接就可以使用semaphore来进行管理。
import threading import time class HtmlSpider(threading.Thread): def __init__(self,url): super().__init__() self.url = url def run(self): time.sleep(2) print("got html text success") class UrlProducer(threading.Thread): def run(self): for i in range(20): # 比如抓取20个网站信息 html_thread = HtmlSpider("http://baidu.com/{}".format(i)) html_thread.start() if __name__ == '__main__': url_producer = UrlProducer() url_producer.start()
我们可以看到结果是20个并发去执行的，如果我们想一次并发3个线程如何处理呢？
更改代码如下：
import threading import time class HtmlSpider(threading.Thread): def __init__(self,url,sem): super().__init__() self.url = url self.sem = sem def run(self): time.sleep(2) print("got html text success") self.sem.release() class UrlProducer(threading.Thread): def __init__(self,sem): super().__init__() self.sem = sem def run(self): for i in range(20): # 比如抓取20个网站信息 self.sem.acquire() html_thread = HtmlSpider("http://baidu.com/{}".format(i),self.sem) html_thread.start() if __name__ == '__main__': sem = threading.Semaphore(3) url_producer = UrlProducer(sem) url_producer.start()
其实semaphore内部是调用了一个condition。我们注意semaphore也是必须有acquire方法和release方法。
另外，我们发现Queue内部也是调用了很多condition的方法。
问：前面介绍了很多同步的方法，其他一些软件都有池的概念，Python也具备吗？
答：当然，Python有两个池子，一个叫线程池，一个叫进程池，后续我们讲到进程的时候回搠进程池。现在先说线程池。
线程池就是concurrent模块包，是在Python3.2时候引入的。这个池是非常顶层的，对于我们进行线程和进程池编码是非好的。而且接口会高度的一致。
一个问题：为什么要有线程池？
目的很简单：就是非常容易的管理线程，线程池自己去调度新的线程去使用，线程池过大的时候会阻塞，知道最新的线程空出来。它不仅仅起到了数量控制，如果我们在主线程当中可以获取某一个线程的状态，或者某一个任务的状态，或者返回值，这样就会变得非常简单。另外，当一个线程完成的时候我们主线程就会立马知道。futures可以让多线程和多进程编码接口一直。
from concurrent.futures import ThreadPoolExecutor import time def get_html(times): time.sleep(times) print("get page {} success".format(times)) return times executor = ThreadPoolExecutor(max_workers=2) # 通过submit函数提交执行的函数到线程池中,submit是立即返回 task1 = executor.submit(get_html,(3)) task2 = executor.submit(get_html,(2)) # done方法用于判定某个人物是否完成 print(task1.done()) # 判定我们的函数是否执行成功的 print(task2.cancel()) # 如我我们执行的状态是执行中是cancel不了的 time.sleep(3) print(task1.done()) # 判定我们的函数是否执行成功的 # result方法可以获取task的执行结果 print(task1.result())
运行结果：
False False get page 2 success get page 3 success True 3
这里面我们用到了ThreadPoolExecutor的类，其中规定了运行的线程数量。
done()方法：判定我们的函数是否执行成功
result()方法：返回函数是否成功执行
cancel()方法：取消一个线程任务（但是如果我们的任务是在执行中，是无法cancel掉的）
另外，我们在想一下，我们想批量的进行提交并且知道提交是否成功怎么写。
这个时候我们需要导入as_completed的模块，as_completed是一个生成器（我们知道生成器最好的方式就用for循环提取出来），我们再用比较高端的推导式的方式进行提交。
from concurrent.futures import ThreadPoolExecutor,as_completed import time def get_html(times): time.sleep(times) print("get page {} success".format(times)) return times executor = ThreadPoolExecutor(max_workers=2) urls = [3,2,4] all_task = [executor.submit(get_html,(url)) for url in urls] for future in as_completed(all_task): data = future.result() # print("get {} page success".format(data))
另外，我们还可以通过executor本身的map方法来完成task
# 通过executor获取已经完成的task for data in executor.map(get_html,urls): print("get {} page success".format(data)) # get page 2 success # get page 3 success # get 3 page success # get 2 page success # get page 4 success # get 4 page success
但是，略有有点儿差别，上面是完成一个打印一个。
再加一个wait等待。这个命令其实也是非常常用而且也是非常好的模块。wait模块是等待某一个函数结束再执行下面的内容。另外wait模块有有个一传参return_when=后面有四种方式：
FIRST_COMPLETED 当地一个执行完毕
FIRST_EXCEPTION
ALL_COMPLETED
_AS_COMPLETED
executor = ThreadPoolExecutor(max_workers=2) urls = [3,2,4] all_task = [executor.submit(get_html,(url)) for url in urls] wait(all_task,return_when='FIRST_EXCEPTION') print("main over")
小结一下：
* 这样关于线程池，我们知道最常用的三个模块：ThreadPoolExecutor, as_completed（注意是一个迭代器）, wait。其中方法有submit，result，cancel，done等方法。wait也是可以传递参数的。
* concurrent.futures 中的Future对象我们一般叫做未来对象，但实际上呢，更形象的说叫task返回容器，task执行结果都会放入里面。
问：线程的内容真是不少，功能也是不少，但是还是挺有规律的。
答：其实线程这块儿，还有几个内容，都非常简单，讲解完毕我们最线程进行总结，然后进入进程方面的讲解。
补充1（threadLocal模块）：我们发现如果两个线程同时操作一个函数的时候，会造成函数中的变量混乱的情况。我们可以通过threadLocal的方法，也叫做线程特定数据。给每一个线程单独去分配一个本地变量可以防止这个问题：代码如下。
import threading num = 0 local = threading.local() def run(x,n): x = x + n x = x - n def func(n): local.value = num for i in range(1000000): run(local.value,n) print("%s--%d" %(threading.current_thread().getName(),local.value)) if __name__ == '__main__': t1 = threading.Thread(target=func,args=(6,)) t2 = threading.Thread(target=func,args=(9,)) t1.start() t2.start() t1.join() t2.join() # # Thread - 1 - -0 # Thread - 2 - -0
补充2（barrier模块）：这个单词是障碍的意思，也就是说像是一个“班车”凑够了多少个“人”才发车。这里就是凑够了多少个线程再进行线程计算，不过这个方法有一个维内托，如果数量不够时候，会一直停在那里等待线程。这种方法平时用的也不是很多。它的方法也是wait，代码如下：
import threading,time bar = threading.Barrier(4) def run(): print("{} -- start".format(threading.current_thread().getName())) time.sleep(1) bar.wait() print("{} -- end".format(threading.current_thread().getName())) if __name__ == '__main__': for i in range(6): threading.Thread(target=run).start()
我们发现：分配6个线程，其实给的是4个，线程6个并发了之后，等待2个结束并发，一直等不到，就停在那里了
补充3（Timer模块）：这个模块很好理解，就是控制线程并发的事件，这是一个定时器，这个定时的事件结束的时候再去开启。
import threading def run(): print("Thomas is running") t = threading.Timer(5,run) print("父线程开始......") t.start() t.join() print("父线程结束......")
补充4（Event模块）：这个模块非常简单，我们使用手工的方式进行线程之间上锁解锁的方式进行通讯，我们可以调用线程的事件（因为线程行动本身就是一个事件），让上一个线程事件等待时间触发。和Condition模块非常的类似。
import threading,time def func(): event = threading.Event() def run(): for i in range(5): event.wait() event.clear() print("Thomas is running") threading.Thread(target=run).start() return event e = func() for i in range(5): e.set() time.sleep(2)
分析代码我们可以看出.wait是阻塞等待时间的触发。clear是重置的意思。set是设定的内容。
补充5（enumerate模块）：略
总结：现在我们可以对Python的进程进行一下总结了。
第一：进程是运行程序最小的操作单元。在IO操作的时候会经常用到。
第二：Python本身具备GIL（全局解释器锁），所以在CPython的解释下，一个线程放入一个CPU下，在诸如PyPy的Python解释器下，就是一种去GIL话的解释器。
第三：进程在上面的框架解释下，是线程交替来进行多线程操作的，系统无法自动的调配多核。
第四：由于线程本身设计的原因，线程在运行程序后会按照自有的规则释放空间，由于这个释放空间的时间非常短暂，造成程序和程序，数据和数据之间可能产生混乱的情况。因此我们引入了锁、event、condition等方式进行控制。
第五：线程有一些概念是成对出现的，正是由于第四条的情况。比如守护和阻塞（daemon和join），wait和clear（event事件），wait和notify（Condition条件），done和wait等。
第六：线程分主线程和子线程这么一说，wait这个模块其实是属于小而精的一种阻塞操作方式，另外我们还可以用with语句来简化代码，用推导式直接进行推送任务到进程中。
第七：平时我们也常用线程池来让Python自动推送任务到线程当中，submit就是这个动作。
第八：诸如像ThreadLocal,Event,Timer,semaphore,barrier等小技巧也需要了解。