突击线程堡垒

线程

什么是线程?

　　类似于进程，进程是正在进行的程序，本身进程就是一个资源单位。线程好比工厂里车间里面的流水线，车间就是一个个的进程，

流水线是用来生产的，因此线程是一个个的执行单位。

　　也就是说进程包含线程（一个或者多个线程）

线程为什么会存在？

　　我们会想，既然有了进程，进程能干的就可以了，为什么还要线程呢？

　　对于这个问题，进程肯定有缺点，正好是线程的优点。那么，进程有哪些缺点呢？

　　1.对于开启一个进程，首先需要申请一个内存空间，所用的时间相比不会少；

　　2.再者，对于创建了一个进程来说，他需要导入模块或者将代买从新拷贝一份到内存中才能执行，这里的时间也不会少。

创建线程的两种方式

类似于进程，一毛一样。

 1 # 创建方式一
 2 # 导入相关模块
 3 from threading import Thread
 4 import time
 5 
 6 # 定义线程函数
 7 def task(name):
 8     print('%s is running' %name)
 9     time.sleep(2)
10     print('%s is over' % name)
11 
12 
13 # 在创建线程中，main可写可不写
14 if __name__ == '__main__':
15     t = Thread(target=task, args=('wanglei',))
16     t.start()
17     print('主')
18 
19 
20 
21 ========打印结果:==============
22 wanglei is running
23 主
24 wanglei is over

 1 # 创建方式二
 2 # 导入相关的模块
 3 from threading import Thread
 4 import time
 5 
 6 
 7 # 定义类方式
 8 class MyThread(Thread):
 9 
10     def __init__(self, name):
11         super().__init__()
12         self.name = name
13 
14     # 定义类方法
15     def run(self):
16         print('%s is running' % self.name)
17         time.sleep(2)
18         print('%s is over' % self.name)
19 
20 
21 # 实例化线程对象
22 t = MyThread('wanglei')
23 # 执行线程
24 t.start()
25 print('主')
# 执行的结果和上面的一样

线程之间的数据共享

场景：定义在主线程的变量可以通过子线程去修改吗？

 1 # 导入模块
 2 from threading import Thread
 3 
 4 
 5 # 定义在主线程中的变量x
 6 x = 100
 7 
 8 # 定义子线程的修改方法
 9 def task():
10     global x
11     x = 666
12 
13 
14 t = Thread(target=task)
15 
16 t.start()
17 
18 =======输出结果:=========
19 666

线程之间的互斥锁

场景：修改数据

 1 from threading import Thread,Lock
 2 import time
 3 import random
 4 
 5 # 生成锁
 6 mutex = Lock()
 7 
 8 # 定义变量n
 9 n = 100
10 
11 # 通过方法去修改n的值
12 def task():
13     global n
14     mutex.acquire()
15     tmp = n
16     time.sleep(0.1)
17     n = tmp -1
18     mutex.release()
19 
20 
21 # 定义列表存放生成的线程对象100个
22 t_list = []
23 for i in range(100):
24     t = Thread(target=task)
25     t.start()
26     t_list.append(t)
27 
28 # 等待所有子线程结束
29 for t in t_list:
30     t.join()
31 
32 print(n)
33 
34 
35 ========输出结果:========
36 0

线程中的守护线程

守护线程：在线程中，在主线程结束的情况下，要等待所有非守护子线程结束才能结束。不同于进程，进程是随着守护的子进程结束而结束。而线程公用一块进程资源，因此即使在守护线程结束的情况下，不排除有其他子线程的存在。

 1 from threading import Thread
 2 import time
 3 
 4 
 5 def task(name):
 6     print('%s is running'%name)
 7     time.sleep(1)
 8     print('%s is over'%name)
 9 
10 if __name__ == '__main__':
11     t = Thread(target=task,args=('王磊',))
12     # t.daemon = True
13     t.start()
14     print('主')