Python系统编程--线程

1.多线程-threading

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

1.1 threading模块的使用

示例：单线程执行

import timedef loveStudy():    print("我爱学习，学习使我快乐")    time.sleep(0.5)if __name__ == "__main__":    for i in range(5):        loveStudy()

运行结果：间隔0.5s，逐个打出

我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐

示例：多线程执行

import threadingimport timedef loveStudy():    print("我爱学习，学习使我快乐")    time.sleep(1)if __name__ == "__main__":    for i in range(5):        t = threading.Thread(target=loveStudy)        t.start() #启动线程，即让线程开始执行

运行结果：结果几乎同时打出

我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐我爱学习，学习使我快乐

说明：
1. 可以明显看出使用了多线程并发的操作，花费时间要短很多
2. 创建好的线程，需要调用start()方法来启动

1.2 主线程会等待所有的子线程结束后才结束

示例：

import threadingfrom time import sleep,ctimedef sing():    for i in range(3):        print("正在唱歌...%d"%i)        sleep(1)def dance():    for i in range(3):        print("正在跳舞...%d"%i)        sleep(1)if __name__ == '__main__':    print('---开始---:%s'%ctime())    t1 = threading.Thread(target=sing)    t2 = threading.Thread(target=dance)    t1.start()    t2.start()    sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？    print('---结束---:%s'%ctime())

运行结果：

---开始---:Mon Jun 12 21:24:35 2017正在唱歌...0正在跳舞...0正在跳舞...1正在唱歌...1正在唱歌...2正在跳舞...2---结束---:Mon Jun 12 21:24:40 2017

1.3 查看线程数量

示例：

import threadingfrom time import sleep,ctimedef sing():    for i in range(3):        print("正在唱歌...%d"%i)        sleep(1)def dance():    for i in range(3):        print("正在跳舞...%d"%i)        sleep(1)if __name__ == '__main__':    print('---开始---:%s'%ctime())    t1 = threading.Thread(target=sing)    t2 = threading.Thread(target=dance)    t1.start()    t2.start()    while True:        length = len(threading.enumerate())        print('当前运行的线程数为：%d'%length)        if length<=1:            break        sleep(0.5)

运行结果：

---开始---:Mon Jun 12 21:26:25 2017正在唱歌...0正在跳舞...0当前运行的线程数为：3当前运行的线程数为：3正在唱歌...1当前运行的线程数为：3正在跳舞...1当前运行的线程数为：3正在唱歌...2正在跳舞...2当前运行的线程数为：3当前运行的线程数为：3当前运行的线程数为：2当前运行的线程数为：1

2. threading注意点

2.1 线程执行代码的封装

通过上一小节，能够看出，通过使用threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法

示例：

import threadingimport timeclass MyThread(threading.Thread):    def run(self):        for i in range(3):            time.sleep(1)            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字            print(msg)if __name__ == '__main__':    t = MyThread()    t.start()

运行结果：

I'm Thread-1 @ 0I'm Thread-1 @ 1I'm Thread-1 @ 2

说明:
• python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

2.2 线程的执行顺序

示例：

import threadingimport timeclass MyThread(threading.Thread):    def run(self):        for i in range(3):            time.sleep(1)            msg = "I'm "+self.name+' @ '+str(i)            print(msg)def test():    for i in range(5):        t = MyThread()        t.start()if __name__ == '__main__':    test()

运行结果：

I'm Thread-1 @ 0I'm Thread-3 @ 0I'm Thread-4 @ 0I'm Thread-2 @ 0I'm Thread-5 @ 0I'm Thread-1 @ 1I'm Thread-3 @ 1I'm Thread-4 @ 1I'm Thread-2 @ 1I'm Thread-5 @ 1I'm Thread-1 @ 2I'm Thread-3 @ 2I'm Thread-4 @ 2I'm Thread-2 @ 2I'm Thread-5 @ 2

说明：
从代码和执行结果我们可以看出，多线程程序的执行顺序是不确定的。当执行到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

总结：
1. 每个线程一定会有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
2. 当线程的run()方法结束时该线程完成。
3. 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
4. 线程的几种状态：

3. 多线程-共享全局变量

示例：

from threading import Threadimport timeg_num = 100#修改全局变量def work1():    #如果想修改全局变量，必须加global    global g_num    for i in range(3):        g_num += 1    print("----in work1, g_num is %d---"%g_num)#获取全局变量def work2():    global g_num    print("----in work2, g_num is %d---"%g_num)#将功能包装成函数方法def main():    print("---线程创建之前g_num is %d---" % g_num)    #创建一个线程    t1 = Thread(target=work1)    #就绪    t1.start()    # 延时一会，保证t1线程中的事情做完    time.sleep(1)    t2 = Thread(target=work2)    t2.start()if __name__ == '__main__':   #调用方法   main()

运行结果：

---线程创建之前g_num is 100-------in work1, g_num is 103-------in work2, g_num is 103---

总结：
• 在一个进程内的所有线程共享全局变量，能够在不适用其他方式的前提下完成多线程之间的数据共享（这点要比多进程要好）
• 缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）

4. 进程VS线程

4.1 功能区别

• 进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ
• 线程，能够完成多任务，比如 一个QQ中的多个聊天窗口

4.2 定义区别

• 进程是系统进行资源分配和调度的一个独立单位.
• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

4.3 区别

• 一个程序至少有一个进程,一个进程至少有一个线程.
• 线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
• 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
• 线程不能够独立执行，必须依存在进程中

4.4 优缺点

线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。

5. 同步的概念

5.1 多线程开发可能遇到的问题

同步不是一起的意思，是协同步调
假设两个线程t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。
但是由于是多线程访问，有可能出现下面情况：
在num=0时，t1取得num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

示例：

import threadingimport time# 全局变量g_num = 0# 函数1def test1():    global  g_num    for i in range(1000000):        #g_num += 1        g_num = g_num+1    print("---test1---g_num=%d" % g_num)# 函数2def test2():    global g_num    for i in range(1000000):        #g_num += 1        g_num = g_num + 1    print("---test2---g_num=%d" % g_num)def main():    #创建线程    t1 = threading.Thread(target=test1)    #就绪    t1.start()    # 创建线程    t2 = threading.Thread(target=test2)    # 就绪    t2.start()    time.sleep(5)    print("---main---g_num=%d" % g_num)if __name__ == '__main__':    main()def main():    #创建线程    t1 = threading.Thread(target=test1)    #就绪    t1.start()    # 创建线程    t2 = threading.Thread(target=test2)    # 就绪    t2.start()    time.sleep(5) #屏蔽此行代码又是一个结果    print("---main---g_num=%d" % g_num)if __name__ == '__main__':    main()

运行结果：

---test1---g_num=1135793---test2---g_num=1134965---main---g_num=1134965

屏蔽后运行结果：

---main---g_num=201214---test1---g_num=1139845---test2---g_num=1157151

问题产生的原因就是没有控制多个线程对同一资源的访问，对数据造成破坏，使得线程运行的结果不可预期。这种现象称为“线程不安全”。

5.2 同步

同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。
“同”字从字面上容易理解为一起动作
其实不是，”同”字应是指协同、协助、互相配合。
如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B依言执行，再将结果给A;A再继续操作。

5.3 解决问题的思路

对于本小节提出的那个计算错误的问题，可以通过线程同步来进行解决思路，如下:
1. 系统调用t1，然后获取到num的值为0，此时上一把锁，即不允许其他现在操作num
2. 对num的值进行+1
3. 解锁，此时num的值为1，其他的线程就可以使用num了，而且是num的值不是0而是1
4. 同理其他线程在对num进行修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性

6. 互斥锁

定义：
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

互斥锁为资源引入一个状态：锁定/非锁定。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以方便的处理锁定：

#创建锁mutex = threading.Lock()#锁定mutex.acquire([blocking])#释放mutex.release()

其中，锁定方法acquire可以有一个blocking参数。
• 如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止（如果没有指定，那么默认为True）
• 如果设定blocking为False，则当前线程不会堵塞

使用互斥锁实现上面的例子的代码如下：

from threading import Thread, Lockimport timeg_num = 0def test1():    global g_num    for i in range(1000000):        #True表示堵塞 即如果这个锁在上锁之前已经被上锁了，那么这个线程会在这里一直等待到解锁为止        #False表示非堵塞，即不管本次调用能够成功上锁，都不会卡在这,而是继续执行下面的代码        mutexFlag = mutex.acquire(True)        if mutexFlag:            g_num += 1            mutex.release()    print("---test1---g_num=%d"%g_num)def test2():    global g_num    for i in range(1000000):        mutexFlag = mutex.acquire(True) #True表示堵塞        if mutexFlag:            g_num += 1            mutex.release()    print("---test2---g_num=%d"%g_num)#创建一个互斥锁#这个所默认是未上锁的状态mutex = Lock()p1 = Thread(target=test1)p1.start()p2 = Thread(target=test2)p2.start()print("---g_num=%d---"%g_num)

运行结果：

---g_num=13557------test2---g_num=1738288---test1---g_num=2000000

示例：模拟售票系统

import threading  import timeimport osdef doChore():  # 作为间隔  每次调用间隔0.5s    time.sleep(0.5)def booth(tid):    global i    global lock    while True:        lock.acquire()                      # 得到一个锁，锁定        if i != 0:            i = i - 1                       # 售票 售出一张减少一张            print(tid, ':now left:', i)    # 剩下的票数            doChore()        else:            print("Thread_id", tid, " No more tickets")            os._exit(0)                     # 票售完   退出程序        lock.release()                      # 释放锁        doChore()#全局变量i = 15                      # 初始化票数lock = threading.Lock()     # 创建锁def main():    # 总共设置了3个线程    for k in range(3):        # 创建线程; Python使用threading.Thread对象来代表线程        new_thread = threading.Thread(target=booth, args=(k,))        # 调用start()方法启动线程        new_thread.start()if __name__ == '__main__':    main()

运行结果：

0 :now left: 141 :now left: 132 :now left: 120 :now left: 111 :now left: 102 :now left: 90 :now left: 81 :now left: 72 :now left: 60 :now left: 51 :now left: 42 :now left: 30 :now left: 21 :now left: 12 :now left: 0Thread_id 0  No more tickets

上锁解锁过程
当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。

每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。

线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。

总结
锁的好处：
• 确保了某段关键代码只能由一个线程从头到尾完整地执行
锁的坏处：
• 阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
• 由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁

7. 死锁

定义
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
尽管死锁很少发生，但一旦发生就会造成应用的停止响应。

示例：

import threadingimport timeclass MyThread1(threading.Thread):    def run(self):        if mutexA.acquire():            print(self.name+'----do1---up----')            time.sleep(1)            if mutexB.acquire():                print(self.name+'----do1---down----')                mutexB.release()            mutexA.release()class MyThread2(threading.Thread):    def run(self):        if mutexB.acquire():            print(self.name+'----do2---up----')            time.sleep(1)            if mutexA.acquire():                print(self.name+'----do2---down----')                mutexA.release()            mutexB.release()mutexA = threading.Lock()mutexB = threading.Lock()if __name__ == '__main__':    t1 = MyThread1()    t2 = MyThread2()    t1.start()    t2.start()

此时已经进入到了死锁状态，可以使用ctrl-z退出

说明：

避免死锁：
• 程序设计时要尽量避免（银行家算法）
• 添加超时时间等

8. 多线程-非共享数据

**
对于全局变量，在多线程中要格外小心，否则容易造成数据错乱的情况发生**

8.1 非全局变量是否要加锁呢？

示例1：

import threadingimport timeclass MyThread(threading.Thread):    # 重写 构造方法    def __init__(self, num, sleepTime):        threading.Thread.__init__(self)        self.num = num        self.sleepTime = sleepTime    def run(self):        self.num += 1        time.sleep(self.sleepTime)        print('线程(%s),num=%d' % (self.name, self.num))if __name__ == '__main__':    mutex = threading.Lock()    t1 = MyThread(100, 5)    t1.start()    t2 = MyThread(200, 1)    t2.start()

运行结果：

线程(Thread-2),num=201线程(Thread-1),num=101

示例2：

import threadingfrom time import sleepdef test(sleepTime):    num=1    sleep(sleepTime)    num+=1    print('---(%s)--num=%d'%(threading.current_thread(), num))t1 = threading.Thread(target = test,args=(5,))t2 = threading.Thread(target = test,args=(1,))t1.start()t2.start()

运行结果：

---(<Thread(Thread-2, started 5276)>)--num=2---(<Thread(Thread-1, started 4828)>)--num=2

总结：
• 在多线程开发中，全局变量是多个线程都共享的数据，而局部变量等是各自线程的，是非共享的

9. 同步应用

示例：多个线程有序执行

from threading import Thread,Lockfrom time import sleepclass Task1(Thread):    def run(self):        while True:            if lock1.acquire():                print("------Task 1 -----")                sleep(0.5)                lock2.release()class Task2(Thread):    def run(self):        while True:            if lock2.acquire():                print("------Task 2 -----")                sleep(0.5)                lock3.release()class Task3(Thread):    def run(self):        while True:            if lock3.acquire():                print("------Task 3 -----")                sleep(0.5)                lock1.release()#使用Lock创建出的锁默认没有“锁上”lock1 = Lock()#创建另外一把锁，并且“锁上”lock2 = Lock()lock2.acquire()#创建另外一把锁，并且“锁上”lock3 = Lock()lock3.acquire()t1 = Task1()t2 = Task2()t3 = Task3()t1.start()t2.start()t3.start()

运行结果:

------Task 1 -----------Task 2 -----------Task 3 -----------Task 1 -----------Task 2 -----------Task 3 -----------Task 1 -----------Task 2 -----------Task 3 -----------Task 1 -----------Task 2 -----------Task 3 -----------Task 1 -----------Task 2 -----------Task 3 -----...省略...

总结：
• 可以使用互斥锁完成多个任务，有序的进程工作，这就是线程的同步

10. 生产者与消费者模式

10.1

队列：先进先出
栈：先进后出

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么就做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

用FIFO队列实现上述生产者与消费者问题的代码如下：

import threadingimport time#python2中#from queue import Queue#python3中from queue import Queueclass Producer(threading.Thread):    def run(self):        global queue        count = 0        while True:            if queue.qsize() < 1000:                for i in range(100):                    count = count +1                    msg = '生成产品'+str(count)                    queue.put(msg)                    print(msg)            time.sleep(0.5)class Consumer(threading.Thread):    def run(self):        global queue        while True:            if queue.qsize() > 100:                for i in range(3):                    msg = self.name + '消费了 '+queue.get()                    print(msg)            time.sleep(1)if __name__ == '__main__':    queue = Queue()    for i in range(500):        queue.put('初始产品'+str(i))    for i in range(2):        p = Producer()        p.start()    for i in range(5):        c = Consumer()        c.start()

10.2 Queue的说明

1. 对于Queue，在多线程通信之间扮演重要的角色
2. 添加数据到队列中，使用put()方法
3. 从队列中取数据，使用get()方法
4. 判断队列中是否还有数据，使用qsize()方法

10.3 生产者消费者模式

• 什么是生产者消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦。

• 为什么要使用生产者和消费者模式
在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

11.ThreadLocal

在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。

11.1 使用函数传参的方法

但是局部变量也有问题，就是在函数调用的时候，传递起来很麻烦：

def process_student(name):    std = Student(name)    # std是局部变量，但是每个函数都要用它，因此必须传进去：    do_task_1(std)    do_task_2(std)def do_task_1(std):    do_subtask_1(std)    do_subtask_2(std)def do_task_2(std):    do_subtask_2(std)    do_subtask_2(std)

每个函数一层一层调用都这么传参数那还得了？用全局变量？也不行，因为每个线程处理不同的Student对象，不能共享。

11.2 使用全局字典

如果用一个全局dict存放所有的Student对象，然后以thread自身作为key获得线程对应的Student对象如何？

global_dict = {}def std_thread(name):    std = Student(name)    # 把std放到全局变量global_dict中：    global_dict[threading.current_thread()] = std    do_task_1()    do_task_2()def do_task_1():    # 不传入std，而是根据当前线程查找：    std = global_dict[threading.current_thread()]    ...def do_task_2():    # 任何函数都可以查找出当前线程的std变量：    std = global_dict[threading.current_thread()]    ...

这种方式理论上是可行的，它最大的优点是消除了std对象在每层函数中的传递问题，但是，每个函数获取std的代码有点low。
有没有更简单的方式？

11.3 使用ThreadLocal

ThreadLocal应运而生，不用查找dict，ThreadLocal帮你自动做这件事：

import threading# 创建全局ThreadLocal对象:local_school = threading.local()def process_student():    # 获取当前线程关联的student:    std = local_school.student    print('Hello, %s (in %s)' % (std, threading.current_thread().name))def process_thread(name):    # 绑定ThreadLocal的student:    local_school.student = name    process_student()t1 = threading.Thread(target= process_thread, args=('yongGe',), name='Thread-A')t2 = threading.Thread(target= process_thread, args=('老王',), name='Thread-B')t1.start()t2.start()t1.join()t2.join()

运行结果：

Hello, yongGe (in Thread-A)Hello, 老王 (in Thread-B)

说明
全局变量local_school就是一个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写而互不干扰，也不用管理锁的问题，ThreadLocal内部会处理。
可以理解为全局变量local_school是一个dict，不但可以用local_school.student，还可以绑定其他变量，如local_school.teacher等等。
ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

11.4 总结

一个ThreadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰。ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题

12. 异步

• 同步调用就是你 喊 你朋友吃饭 ，你朋友在忙 ，你就一直在那等，等你朋友忙完了 ，你们一起去
• 异步调用就是你 喊 你朋友吃饭 ，你朋友说知道了 ，待会忙完去找你 ，你就去做别的了。

示例：

from multiprocessing import Poolimport timeimport osdef test():    print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))    for i in range(3):        print("----%d---"%i)        time.sleep(1)    return "hahah"def test2(args):    print("---callback func--pid=%d"%os.getpid())    print("---callback func--args=%s"%args)if __name__ == '__main__':    pool = Pool(3)    pool.apply_async(func=test,callback=test2)    time.sleep(5)    print("----主进程-pid=%d----"%os.getpid())

运行结果：

---进程池中的进程---pid=4544,ppid=1868------0-------1-------2------callback func--pid=1868---callback func--args=hahah----主进程-pid=1868----