线程

1. 什么是线程

线程就是进程里面的执行单位，每一个进程肯定都自带一个线程，真正被cpu执行的是线程，线程是代码的执行过程，该过程中需要的资源都找对应的进程要
进程是资源的单位，线程是执行单位！

补充：同一个进程里面的多个线程资源是共享的！
2. 为啥要有线程

一个进程里面可以开设多个线程，而开设线程是不需要申请内存空间的（进程需要），因此，开设线程的消耗远远小于进程！
3. 如何使用线程

3.1 创建线程的第一种方式（掌握）

1. from threading import Thread # 导入线程模块
2. from multiprocessing import Process
3. import time
5. # 定义子线程函数
6. def func(name):
7.     print('%s 来啦'%name)
8.     time.sleep(2)
9.     print('%s走了'%name)
11. # 创建线程不需要写在main下，但是我们还是习惯性的把它写在main下
12. if __name__ == '__main__':
13.     # 创建线程对象
14.     t = Thread(target=func,args=('zhang',))
15.     # p = Process(target=func,args=('zhang',))
16.     # p.start()
17.     t.start() # 启动线程
18.     # 线程和进程的开启相比，线程更加的块，线程不需要开辟内存空间
19.     print('主')

复制代码

3.2 创建线程的第二种方式

1. from threading import Thread
3. # 1.创建一个类，该类继承线程类
4. class MyThread(Thread):
5.     # 第二种方法需要给子线程添加参数的方法是类中有一个双init方法
6.     # 先继承父类的双init方法，然后在书写需要自己加入的参数，这样就可以在run函数里调用参数了
7.     def __init__(self,name):
8.         super().__init__()
9.         self.name = name
10.     # 2.该类中子线程函数名必须是run
11.     def run(self):
12.         print('我是线程%s'%self.name)
14. if __name__ == '__main__':
15.     # 3.创建子线程对象
16.     t = MyThread('zhang')
17.     # 4.开启子线程
18.     t.start()
19.     print('主')

复制代码

3.3 线程中的join方法

join方法的含义是：主线程等待子线程运行完毕再执行

1. from threading import Thread # 导入线程模块
2. from multiprocessing import Process
3. import time
5. def func(name):
6.     print('%s 来啦'%name)
7.     time.sleep(1)
8.     print('%s走了'%name)
10. if __name__ == '__main__':
11.     t = Thread(target=func,args=('zhang',))
12.     t.start()
13.     t.join() # join方法的含义是：主线程等待子线程运行完毕再执行
14.     print('主')

复制代码

3.4 线程对象和其他方法

1. from threading import Thread,active_count,current_thread
2. import time,os
4. def func():
5.     # os.getpid()获取当前线程的进程id，主线程和子线程id相同
6.     # print('hello',os.getpid())
7.     # current_thread().name获取当前线程的线程名
8.     print('hello', current_thread().name)
9.     time.sleep(2)
11. if __name__ == '__main__':
12.     t = Thread(target=func)
13.     t.start()
14.     # print('主',current_thread().name)
15.     # active_count() 获取当前活跃的线程数量
16.     print('主',active_count())

复制代码

3.5 守护线程

1. from threading import Thread
2. import time
4. def func(name):
5.     print('%s来啦'%name)
6.     time.sleep(2)
7.     print('%s走了'%name)
9. if __name__ == '__main__':
10.     t = Thread(target=func,args=('zhang',))
11.     t.daemon = True # 守护主线程，主线程结束之后该子线程也会结束
12.     t.start()
13.     print('主')
14.     """
15.     主线程一般不会自动结束，它会等待所有非守护线程结束之后再结束
16.     因为主线程结束意外着主进程也结束了，这样其他线程就无法调用主进程的资源了
17.     """

复制代码

3.6 线程的互斥锁

1. from threading import Thread,Lock
2. import time
4. momey = 100
5. # 加一把锁
6. metua = Lock()
8. def func():
9.     global momey
10.     # 在获取数据的前面加一把锁
11.     metua.acquire()
12.     num = momey
13.     time.sleep(0.01)
14.     momey = num -1
15.     # 释放该锁
16.     metua.release()
18. if __name__ == '__main__':
19.     t_list = []
20.     for i in range(100):
21.         t = Thread(target=func)
22.         t.start()
23.         t_list.append(t)
24.     for t in t_list:
25.         t.join()
26.     print(momey)

复制代码

3.7 GIL锁与互斥锁

GIL需要知道的重点：

1.         1.GIL不是python的特点而是CPython解释器的特点
2.         2.GIL是保证解释器级别的数据的安全
3.         3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)
4.         4.针对不同的数据还是需要加不同的锁处理
5.         5.解释型语言的通病:同一个进程下多个线程无法利用多核优势

复制代码

GIL锁与互斥锁的区别

1. from threading import Thread,Lock
2. import time
4. momey = 100
5. # 加一把锁
6. metua = Lock()
8. def func():
9.     global momey
10.     # 在获取数据的前面加一把锁
11.     metua.acquire()
12.     num = momey
13.     time.sleep(0.01) # 注意：这里sleep是在模拟网络延迟。如果假设没有网络延迟，没有互斥锁LOCK，得到money的结果也应为0，因为一个进程里有一个cpython解释器，cpython解释器有一个GIL锁的概念，同一个进程下的多个线程无法同时执行，它们必须去抢同一个GIL锁，没有网络延迟（没有IO），GIL锁就会直到数据操作完在释放，保证了多个线程执行的数据安全；但是实际上是有网络延迟的，就比如sleep，这时GIL锁就会直接释放掉，导致得到的money=99
14.     momey = num -1
15.     # 释放该锁
16.     metua.release()
18. if __name__ == '__main__':
19.     t_list = []
20.     for i in range(100):
21.         t = Thread(target=func)
22.         t.start()
23.         t_list.append(t)
24.     for t in t_list:
25.         t.join()
26.     print(momey)

复制代码

3.8多线程与多进程的比较

当需要处理的工作大都是是计算密集型时优先考虑多进程（较好的利用多核优势）
当需要处理的工作大都是IO密集型时优先考虑多线程（节省空间消耗）

计算密集型就是计算处理偏多
IO密集型就是用户输入输出偏多

1. # 当处理的工作是计算密集型的时候，好像现在多线程比多进程有优势？？？待验证！
2. from multiprocessing import Process
3. from threading import Thread
4. import os,time
6. def work():
7.     res = 0
8.     for i in range(1000000):
9.         res *= i
11. if __name__ == '__main__':
12.     list = []  # 将下面for循环每次开设的线程/进程对象存储起来
13.     print(os.cpu_count()) # 获取当前计算机的CPU个数
14.     start_time = time.time()  # 获取开始时间
15.     for i in range(16): # for循环开设进程/线程
16.         # p = Process(target=work)
17.         p = Thread(target=work)
18.         p.start()
19.         list.append(p) # 将每次开设的进程对象添加到列表里
20.     for p in list: # 变量进程对象
21.         p.join() # 守护主进程/线程
22.     print(time.time()-start_time)
23.     # 计算密集型 多进程用时1.8412911891937256秒  多线程用时0.318603515625秒

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！