Pyton（八）1、线程

廖雪峰官网的解释：  （我想比我解释的更好）

很多同学都听说过，现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。

什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。

由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

我们前面编写的所有的Python程序，都是执行单任务的进程，也就是只有一个线程。如果我们要同时执行多个任务怎么办？

有两种解决方案：

一种是启动多个进程，每个进程虽然只有一个线程，但多个进程可以一块执行多个任务。

还有一种方法是启动一个进程，在一个进程内启动多个线程，这样，多个线程也可以一块执行多个任务。

当然还有第三种方法，就是启动多个进程，每个进程再启动多个线程，这样同时执行的任务就更多了，当然这种模型更复杂，实际很少采用。

总结一下就是，多任务的实现有3种方式：

• 多进程模式；
• 多线程模式；
• 多进程+多线程模式。

同时执行多个任务通常各个任务之间并不是没有关联的，而是需要相互通信和协调，有时，任务1必须暂停等待任务2完成后才能继续执行，有时，任务3和任务4又不能同时执行，所以，多进程和多线程的程序的复杂度要远远高于我们前面写的单进程单线程的程序。

因为复杂度高，调试困难，所以，不是迫不得已，我们也不想编写多任务。但是，有很多时候，没有多任务还真不行。想想在电脑上看电影，就必须由一个线程播放视频，另一个线程播放音频，否则，单线程实现的话就只能先把视频播放完再播放音频，或者先把音频播放完再播放视频，这显然是不行的。

Python既支持多进程，又支持多线程，我们会讨论如何编写这两种多任务程序。

小结

线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定，程序自己不能决定什么时候执行，执行多长时间。

多进程和多线程的程序涉及到同步、数据共享的问题，编写起来更复杂。

来源于：http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319272686365ec7ceaeca33428c914edf8f70cca383000

自己总结：进程就是一个电影播放器，电影的图像是一个函数，声音也是一个函数，多线程是让这两个函数同时运行的那么一个类，线程就是干这么一件事的（让多个函数同时并发）。

　　　　（其实不是同时并发的，cpu快速遍历每个函数（这个速度很快很快），以至于让我们感觉他们同时进行的。）

一、线程

　　1.基础操作

　　2.线程锁

　　3.其他

　　基础操作：

#线程 让多个函数同时并发。
#基本格式。
from threading import Thread
import time

def f(xxx):
    print(xxx)
    time.sleep(5)
    print("nnn")

def f1(zzz):
    print(zzz)
    time.sleep(5)
    print("mmm")

  
t = Thread(target=f,args = (123,))
t.start()
t = Thread(target=f1,args= (456,))
t.start()

　　线程常用方法：

• t.start() : 激活线程
• t.getName() : 获取线程的名称
• t.setName() ： 设置线程的名称 
• t.name : 获取或设置线程的名称
• t.is_alive() ： 判断线程是否为激活状态
• t.isAlive() ：判断线程是否为激活状态
• t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之前才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
• t.isDaemon() ： 判断是否为守护线程
• t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None
• t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
• t.run() ：线程被cpu调度后自动执行线程对象的run方法

二、线程锁：

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

　　　优缺点：锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下             降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。

　　  自我总结：功能有点类似与join函数，都是为了保证线程有序的执行。

　　1.基本操作

　　加锁 acquire()   释放锁release()  

from threading import Thread,RLock
import time



num = 0
lock = RLock()  #创建实例　　
def func(a):
    lock.acquire()   #先获取锁
    global num
    num += 1
    print(num)
    lock.release()   #释放锁
for i in range(500):
    t = Thread(target=func, args=(10,))
    t.start()

三、event()   线程阻塞

　　　　Event是线程间通信最间的机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者            使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

　　　　自我总结： 该方法是为了实现人工并发。

　　操作示范：

import threading

def f1(a,b):
    print(a)
    b.wait()   # 让函数执行到这一步全部阻塞住。
    print("b")



#创建一个实例
even = threading.Event()

#创建10个线程
for i in range(10):
    t = threading.Thread(target=f1, args=("你好",even))
    t.start()

inp = input(">>>")
if inp == "1":
    even.set()  #打开阻塞
#even.clear() 清除set   再次阻塞

　　常用方法介绍

• Event.wait([timeout]) ： 堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）
• Event.set() ：将标识位设为Ture
• Event.clear() ： 将标识伴设为False
• Event.isSet() ：判断标识位是否为Ture

queue 队列：

　　　　适用于多线程编程的先进先出数据结构，可以用来安全的传递多线程信息。

　　　　自己总结：队列就是指定一个限制性的通道，所有的线程都需要排队，先来的先执行。

from Lib.queue import Queue

import threading

que = Queue(4)   #指定队列的长度。

def s(i):
    que.put(i)       #put是放进去，当次数大于3时，就停止不放，等取出来一个然后再放。
    print("put",i)


def x(i):
    g = que.get(i)  #get 是取出来
    print("get",g)


for i in range(5):
    t = threading.Thread(target=s,args=(i,))
    t.start()


for i in range(5):
    t = threading.Thread(target=x,args=(i,))
    t.start()

"""
#输出结果
put 0
put 1
put 2
put 3
get 0
put 4
get 1
get 2
get 3
get 4
"""

　　队列的其它方法：

• q = queue.Queue(maxsize=0) # 构造一个先进显出队列，maxsize指定队列长度，为0 时，表示队列长度无限制。
• q.join() 　　# 等到队列为kong的时候，在执行别的操作
• 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)