多线程和线程池并不是一回事
多线程是根据实际情况建立多个线程,线程池是一次性创建多个线程。
简单来说,目前有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中的多线程技术就介绍到这里,下一步研究线程池的问题。不过我自己还是有疑问,如果不停的创建线程肯定不行,那如何结束线程呢?如何阻塞、挂起线程呢?又不得而知。。。