python线程
创建线程(两种方式)
创建线程方式一:
1 from threading import Thread
2 def f1(n):
3 print('%s号线程任务'%n)
4
5 def f2(n):
6 print('%s号线程任务'%n)
7
8 if __name__ == '__main__':
9 t1 = Thread(target=f1,args=(1,))
10 t2 = Thread(target=f2,args=(2,))
11 t1.start()
12 t2.start()
13 print('主线程')
14 结果
15 1号线程任务
16 2号线程任务
17 主线程
创建线程方式二:
1 class MyThread(Thread):
2 def __init__(self,name):
3 super().__init__()
4 self.name = name
5
6 def run(self):
7 print('%s号子线程'%self.name)
8
9 if __name__ == '__main__':
10 t = MyThread('1')
11 t.start()
12 print('主线程结束')
13 结果
14 1号子线程
15 主线程结束
查看线程PID
1 from threading import Thread
2 import os
3
4 def f1(n):
5 print('%s号线程任务'%n)
6 print('1号线程PID',os.getpid())
7
8 def f2(n):
9 print('%s号子线程任务'%n)
10 print('2号线程PID',os.getpid())
11
12 if __name__ == '__main__':
13 t1 = Thread(target=f1,args=(1,))
14 t2 = Thread(target=f2,args=(2,))
15 t1.start()
16 t2.start()
17 print('主线程')
18 print('主线程PID',os.getpid())
验证线程之间是数据共享的
1 from threading import Thread
2
3 #通过对全局变量的修改来验证线程之间是数据共享的,共享同一进程中的数据
4 num = 111
5 def f1(n):
6 global num
7 num = 222
8 print('子线程num',num)
9
10 if __name__ == '__main__':
11 t = Thread(target=f1,args=(1,))
12 t.start()
13 # 等待子线程运行结束才继续往下执行
14 t.join()
15 print('主线程num',num)
16 结果
17 子线程num 222
18 主线程num 222
多进程与多线程效率对比
1 import time
2 from threading import Thread
3 from multiprocessing import Process
4 def f1():
5 # time.sleep(1) #io密集型
6
7 #计算型
8 n = 0
9 for i in range(10000000):
10 n += i
11
12 if __name__ == '__main__':
13
14 # 查看一下5个线程执行5个任务的执行时间(一个线程一个任务)
15 t_s_time = time.time()
16 t_list = []
17 for i in range(5):
18 t = Thread(target=f1,)
19 t.start()
20 t_list.append(t)
21 t_e_time = time.time()
22 t_dif_time = t_e_time - t_s_time
23
24 # 查看一下5个进程执行同样的任务的执行时间(一个进程一个任务)
25 p_s_time = time.time()
26 p_list = []
27 for i in range(5):
28 p = Process(target=f1,)
29 p.start()
30 p_list.append(p)
31 [pp.join() for pp in p_list]
32 p_e_time = time.time()
33 p_dif_time = p_e_time - p_s_time
34 print('多线程的执行时间',t_dif_time)
35 print('多进程的执行时间',p_dif_time)
锁
1 import time
2 from threading import Lock,Thread
3
4 num = 111
5 def f1(loc):
6 loc.acquire()
7 global num
8 num -= 1
9 time.sleep(0.001)
10 loc.release()
11
12 if __name__ == '__main__':
13 t_loc = Lock()
14 t_list = []
15 for i in range(10):
16 t = Thread(target=f1,args=(t_loc,))
17 t.start()
18 t_list.append(t)
19 [tt.join() for tt in t_list]
20 print('主线程的num',num)
21 结果
22 主线程的num 101
死锁现象及递归锁解决方案(锁嵌套锁)
1 import time
2 from threading import Thread,Lock,RLock
3 def f1(locA,locB):
4 locA.acquire()
5 print('f1抢到了A锁')
6 time.sleep(1)
7 locB.acquire()
8 print('f1抢到了B锁')
9 locB.release()
10 locA.release()
11
12 def f2(locA,locB):
13 locB.acquire()
14 print('f2抢到了B锁')
15 locA.acquire()
16 time.sleep(1)
17 print('f2抢到了A锁')
18 locA.release()
19 locB.release()
20
21 if __name__ == '__main__':
22 locA = Lock()
23 locB = Lock()
24
25 #递归锁,维护一个计数器,acquire一次就加1,release就减1(为了解决死锁问题)
26 #locA = locB = RLock()
27 t1 = Thread(target=f1,args=(locA,locB))
28 t2 = Thread(target=f2,args=(locA,locB))
29 t1.start()
30 t2.start()
31 死锁结果
32 f1抢到了A锁
33 f2抢到了B锁
34 ... 程序不会结束,一直等待
35
36 递归锁结果
37 f1抢到了A锁
38 f1抢到了B锁
39 f2抢到了B锁
40 f2抢到了A锁
多线程与多进程守护程序的区别
1 from threading import Thread
2 from multiprocessing import Process
3
4 def f1():
5 time.sleep(2)
6 print('1号线程')
7
8 def f2():
9 time.sleep(3)
10 print('2号线程')
11
12 if __name__ == '__main__':
13 # 守护线程:守护线程会等待所有非守护线程运行结束才结束
14 # t1 = Thread(target=f1,)
15 # t2 = Thread(target=f2,)
16 # t1.daemon = True
17 # t2.daemon = True
18 # t1.start()
19 # t2.start()
20 # print('主线程结束')
21
22 # 守护进程: 主进程代码执行运行结束, 守护进程随之结束
23 # t1 = Process(target=f1,)
24 # t2 = Process(target=f2,)
25 # t1.daemon = True
26 # t2.daemon = True
27 # t1.start()
28 # t2.start()
29 # print('主进程结束')
30 多线程守护程序结果
31 1号线程
32 2号线程
33 主线程结束
34
35 多进程守护程序结果
36 主进程结束
子进程不能input
1 from threading import Thread
2 from multiprocessing import Process
3
4 def f1():
5 name = input('<<<:')
6 print(name)
7 if __name__ == '__main__':
8 input('主进程输入:')
9 p = Process(target=f1,)
10 p.start()
11 print('主进程结束')
12
13 # p = Thread(target=f1,)
14 # p.start()
15 # print('主进程结束')
16
17 子进程如果input报错
18 EOFError: EOF when reading a line
19
20 线程不需要main
21 <<<:主进程结束
线程事件(方法同进程一样)
1 import time
2 from threading import Thread,Semaphore,Event
3 def f1():
4 sm.acquire()
5 print('哈哈哈')
6 time.sleep(1)
7 sm.release()
8 if __name__ == '__main__':
9 sm = Semaphore(5)
10 for i in range(2):
11 t = Thread(target=f1,)
12 t.start()
13
14 e = Event()
15 print(e.is_set())
16 print('开始等待')
17 e.set()
18 # e.clear()
19 e.wait() #当e对象的状态为False的时候会在这个地方阻塞,改为true之后就直接往下执
20 print(e.is_set())
21 print('结束等待')
浙公网安备 33010602011771号