异步编程（二）----------------多线程
多线程和线程池并不是一回事
多线程是根据实际情况建立多个线程，线程池是一次性创建多个线程。
简单来说，目前有10个任务。多线程技术就是为10个任务建立10个线程。线程池可以一次性创建5个线程，来一个任务，就从线程池里取走一个线程，直到5个线程全部取走；同理，某一个线程任务结束之后，要归还给线程池。线程池有点像现在的租“充电宝”，充电宝就这么多，借完了再借就需要等，用完了还要放回去。
先来说用python实现多线程技术。python中的多线程技术是基于threading模块，先来一段代码，实现多线程技术。
import threading #计算0-9的平方和 sum1 = 0 sum2 = 0 def square_1(): global sum1 for i1 in range(10): sum1 = sum1+i1**2 #计算0-9的立方和 def square_2(): global sum2 for i2 in range(10): sum2 = sum2+i2**3 if __name__ == '__main__': s1 = threading.Thread(target=square_1，name = 's1') s2 = threading.Thread(target=square_2, name = 's2') s1.start() s2.start() print(sum1,sum2)
输出：
285 2025
这段小程序的意思是：square_1()计算0-9的平方和，square_2()计算0-9的立方和。这个中间还复习了下全局变量。。。在函数square_1()和square_2()使用全局变量要用global 强调下，否则报错。
通过threading.Thread（） 创建线程，参数target=函数名（注意函数名后边没有括号），实例化对象s1、s2。通过s1.start()、s2.start() 启动线程。需要注意的是，两个线程从微观看是串行完成的，在CPU内部，一会执行进程s1、一会执行进程s2，没有规律，最后s1和s2谁也先执行完也不确定。就算交换s1.start()和s2.start()，谁先计算完也不确定。但是从宏观来看，是并发完成的。验证下：交换s1.start()、s2.start() ，结果：
285 2025
两次执行结果都一样，可以断定执行顺序和start()顺序是没关系的，但是又能说明一个问题，2次方比3次方运算量小，所以先执行完。
下一个问题：如果线程需要传参，怎么办呢？例如刚才的例子，需要在main()中设定参数：
import threading #计算0-9的平方和 sum1 = 0 sum2 = 0 def square_1(nb1): global sum1 for i1 in range(nb1): sum1 = sum1+i1**2 #计算0-9的立方和 def square_2(nb2): global sum2 for i2 in range(nb2): sum2 = sum2+i2**3 if __name__ == '__main__': s1 = threading.Thread(target=square_1,args=(10,),name = 's1') s2 = threading.Thread(target=square_2,args=(10,),name = 's2') s2.start() s1.start() print(sum1,sum2)
将函数定义中的10改为形参，在线程创建中添加参数args=()，这个括号代表是一个元组，将实参一个一个传进去，如果只有一个实参，就写为(10,)，括号里边的逗号‘，’是不能够省略的。
下一个问题：多线程真的能节省时间吗？
为了验证，写一段代码，大体思路是用多线程计算平方和 和立方和，再用串行的方式计算平方和 和立方和。为了让时间久一点，将计算量加大。
import time import threading #计算0-9的平方和 sum1 = 0 sum2 = 0 def square_1(nb1): global sum1 for i1 in range(nb1): sum1 = sum1+i1**2 #计算0-9的立方和 def square_2(nb2): global sum2 for i2 in range(nb2): sum2 = sum2+i2**3 if __name__ == '__main__': start_time = time.time() s1 = threading.Thread(target=square_1,args=(1000,),name = 's1') s2 = threading.Thread(target=square_2,args=(1000,),name = 's2') s2.start() s1.start() s1.join() s2.join() end_time = time.time() print('多线程时间：',end_time-start_time) start_time = time.time() square_1(1000) square_2(1000) end_time = time.time() print('串行：', end_time - start_time)
输出：
多线程时间： 0.0019998550415039062
串行： 0.0010001659393310547
发现多线程的时间居然还要比串行时间要多一倍。观察代码，也没有发现问题。这是因为python中自带的GIL锁，有兴趣大家可以自行百度一下。这个GIL锁说白了，就是保证一个进程中只有一个线程在执行。那为什么多线程时间更久呢？应该一样才对呀，其实线程之间来回切换也要有时间开销。
很多同学就要说了，多线程没有研究的必要？既然比串行工作效率还要低，为什么还要研究它？
这就要说我们平常借助计算机工作的两大类任务：一类是CPU密集型，一类是IO密集型。顾明思议：CPU密集型是指任务以计算为主，IO密集型是指任务以IO为主。像刚才写的程序就以CPU计算为主。
CPU密集型任务使用多线程反而会降低效率，但是IO密集型任务使用多线程就可以提高效率，比如爬虫就是IO密集型。
细心的同学发现上一段代码中，比上上一段代码多了一个jion()，这个是干嘛的呢？来一个例子说明一下：
import threading import time def func1(): print('NO.1') time.sleep(0.5) print('NO.2') def func2(): print('NO.a') time.sleep(0.5) print('NO.b') if __name__ == '__main__': f1 = threading.Thread(target=func1) f2 = threading.Thread(target=func2) f1.start() f2.start() print('NO.A') print('NO.B')
输出：
NO.1 NO.a NO.A NO.B NO.2 NO.b
发现结果和我们预想的不一样，如果按照之前的知识，主函数中的print('NO.A')、print('NO.B')应该在两个线程执行完之后再执行，结果并非如此。
线程并没有等待主进程，怎么办呢？jion()可以解决，现在我们添加两个线程的jion()：
import threading import time def func1(): print('NO.1') time.sleep(0.5) print('NO.2') def func2(): print('NO.a') time.sleep(0.5) print('NO.b') if __name__ == '__main__': f1 = threading.Thread(target=func1,name = 'f1') f2 = threading.Thread(target=func2,name = 'f2') f1.start() f2.start() f1.join() f1.join() print('NO.A') print('NO.B')
输出：
NO.1 NO.a NO.b NO.2 NO.A NO.B
这样就解决了这个问题，jion()可以让线程结束之后再执行下边的进程。
细心的同学又说了，线程f1和f2的执行毫无规律啊，要想变得有规律，怎么办呢？比如交叉运行？一人执行一步，谁也别抢？或者说有一个全局变量或内存空间，两个线程都需要访问，但是一个线程在访问的时候，另外一个线程不能访问，怎么操作？这就是操作系统中的生产者消费者的问题。解决方式考“锁”。例如A、B两个人都要进一个屋子，这个屋子不能让AB同时访问，可以给A、B每人一把锁。A进门的时候看门上有没有锁，没有锁才进去，进去的同时把门锁上，出来的时候再把锁打开。同理B。python中的threading模块已经写好了“锁”，下边上代码，先看没有锁是什么情况：
import threading import time # 定义线程运行函数 def ji(): for i in range(0,10,2): print(i) time.sleep(0.5) def ou():for i in range(1,10,2): print(i) time.sleep(0.5) if __name__ == '__main__': th = threading.Thread(target=ji) th2 = threading.Thread(target=ou) th.start() th2.start()
输出：
0
1
23
5
4
76
89
再看加锁之后：
代码：
import threading import time # 定义线程运行函数 def ou(): for i in range(0,10,2): lock_ou.acquire() print(i) lock_ji.release() time.sleep(0.5) def ji()for i in range(1,10,2): lock_ji.acquire() print(i) lock_ou.release() time.sleep(0.5) if __name__ == '__main__': lock_ji = threading.Lock() lock_ou = threading.Lock() th = threading.Thread(target=ji) th2 = threading.Thread(target=ou) lock_ji.acquire() th.start() th2.start()
输出：
0
1
2
3
4
5
6
7
8
9
代码功能上看起来很简单，一个线程输出奇数、一个线程输出偶数。如果没有“锁”，输出会很乱，一会奇数一会偶数，甚至连换行都来及输出，甚至以下输出两个换行符。加上“锁”之后，就符合我们的设想，一人一步，谁也别抢。
“锁”是通过threading.Lock()创建lock_ji、lock_ou对象，调用lock_ji.acquire()、 lock_ou.acquire()上锁，lock_ji.release()、lock_ou.release()释放锁，为了保证先输出偶数，在主函数中，有lock_ji.acquire()。有同学说了，为啥用两把锁呢？因为一把锁实现不了。。。不信的同学可以试一下，说白了还是《操作系统》中生产者、消费者的问题。。。
注意代码中锁的位置：
在def ji()中，先给ou上锁，执行完print之后再释放ji的锁；在def ji()中，先给ji上锁，执行完print之后再释放ou的锁。再联合主函数中的先给ji上锁，整体理解就没有问题了。
对应到操作系统中，print就是临界区资源。
补充：
利用消息队列接收进程返回值。
import time import threading from queue import Queue #计算0-9的平方和 def square_1(nb1,q): sum1 = 0 for i1 in range(nb1): sum1 +=i1**2 time.sleep(1) q.put(sum1) #计算0-9的立方和 def square_2(nb2,q): sum2 = 0 for i2 in range(nb2): sum2 += i2 ** 3 q.put(sum2) if __name__ == '__main__': q = Queue() s1 = threading.Thread(target=square_1,args=(10,q),name = 's1') s2 = threading.Thread(target=square_2,args=(10,q),name = 's2') s1.start() s2.start() s1.join() s2.join() print(q.get(),q.get())
输出：
2025 285
实例化对象q = Queue()，q.put(参数) 将参数加入到消息队列中，q.get()从消息队列中取出。遵循FIFO，即先进先出，第一个q.put()到消息队列的，第一个q.get()被得到。
在函数定义形参中，要加入q，在进程创建threading.Thread()中，参数args要加上q。完毕。。。
好了，python中的多线程技术就介绍到这里，下一步研究线程池的问题。不过我自己还是有疑问，如果不停的创建线程肯定不行，那如何结束线程呢？如何阻塞、挂起线程呢？又不得而知。。。
