1 import time
 2 from multiprocessing import Process
 3 from threading import Thread
 4 
 5 
 6 def func(i):
 7     return '我是任务%s'%i
 8 
 9 
10 if __name__ == '__main__':
11 
12     # 多线程
13     t_list = []
14     t_start_time = time.time()
15     for i in range(10):
16         t = Thread(target=func,args=(i,))
17         t_list.append(t)
18         t.start()
19 
20     [tt.join() for tt in t_list]
21     t_end_time = time.time()
22     t_dif_time = t_end_time - t_start_time
23 
24     # 多进程
25     p_list = []
26     p_start_time = time.time()
27     for i in range(10):
28         p = Process(target=func,args=(i,))
29         p_list.append(p)
30         p.start()
31 
32     [pp.join() for pp in p_list]
33     p_end_time = time.time()
34     p_dif_time = p_end_time - p_start_time
35     # 结果受cpu影响
36     
37     print('多线程耗时：',t_dif_time)
38     print('多进程耗时：',p_dif_time)
39     print('主线程结束')
40 
41 '''
42 多线程耗时： 0.0020008087158203125
43 多进程耗时： 0.4188823699951172
44 '''

 1 import time
 2 from threading import Thread
 3 
 4 num = 100
 5 
 6 def func():
 7     global num
 8     tep = num  # tep替换 模拟多步操作
 9     time.sleep(0.001)  # 模拟延迟
10     tep -= 1
11     num = tep
12 
13 
14 if __name__ == '__main__':
15 
16     t_list = []
17     for i in range(100):
18         t = Thread(target=func,)
19         t_list.append(t)
20         t.start()
21 
22     [tt.join() for tt in t_list]
23 
24     print('主线程的num',num)  # 打印出不是100可知数据是共享的
25 
26 # 理论上应该是0，但多线程是并发执行的，会出现上一个线程还在运算中时，下一个线程并未等待它返回值
27 # 也拿了原来的值进来运算，所以打印出了91,92,93不等，可知多线程数据是不安全的
28 '''
29 主线程的num 92
30 '''

 1 import time
 2 from threading import Thread,Lock
 3 
 4 num = 100
 5 def func(lock,i):
 6     global num
 7     lock.acquire()  # 加锁
 8     
 9     tep = num
10     time.sleep(0.001)  # 模拟延迟
11     tep -= 1
12     num = tep
13 
14     lock.release()  # 释放
15 
16 
17 if __name__ == '__main__':
18     t_list = []
19     lock = Lock()
20     for i in range(100):
21         t = Thread(target=func,args=(lock,i))
22         t_list.append(t)
23         t.start()
24 
25     [tt.join() for tt in t_list]
26     print('主线程num',num)
27 
28 '''
29 主线程num 0
30 '''

 1 import time,random
 2 from threading import Thread,Semaphore
 3 
 4 
 5 def func(i,s):
 6     s.acquire()
 7     print('%s张烧饼'%i)
 8     time.sleep(random.randint(1,3))
 9     s.release()
10     # 出来一个进去一个 始终6个  最后不足6个就都进来了
11 
12 
13 if __name__ == '__main__':
14     s = Semaphore(6)  # 与Lock类似，不过可限制最大连接数，如这里同时只有6个线程可以获得semaphore
15     for i in range(28):
16         t = Thread(target=func,args=(i,s,))
17         t.start()

 1 import time
 2 from threading import Thread,Lock
 3 
 4 
 5 def func1(lock_A,lock_B):
 6     lock_A.acquire()
 7     print('张全蛋拿到了A锁')
 8     time.sleep(0.5)
 9     lock_B.acquire()
10     print('张全蛋拿到了B锁')
11     lock_B.release()
12     lock_A.release()
13 
14 
15 def func2(lock_A,lock_B):
16     lock_B.acquire()
17     print('赵二狗拿到了B锁')
18     lock_A.acquire()
19     print('赵二狗拿到了A锁')
20     lock_A.release()
21     lock_B.release()
22 
23 
24 if __name__ == '__main__':
25 
26     lock_A = Lock()
27     lock_B = Lock()
28     t1 = Thread(target=func1,args=(lock_A,lock_B,))
29     t2 = Thread(target=func2,args=(lock_A,lock_B,))
30     t1.start()
31     t2.start()