线程全局修改
x = 100
def func1():
global x
print(x)
changex()
print(x)
def changex():
global x
x = 50
func1()
"""
100
50
"""
线程锁
from threading import Thread, Lock
x = 0
mutex = Lock()
def task():
global x
mutex.acquire() #加了锁之后就能保证每次只有一个运行，就不会出现数据丢失现象，不过效率会降低
for i in range(100000):
x = x + 1
"""
如果不加锁，那么（以下的情况属于假设）：
t1 的 x 刚拿到0（属于IO） 保存好状态，这时候CPU切换给t2运行。
t2 的 x拿到 0 并进行+1 操作 这时候x是1（运行完CPU切换）
t1 又获得运行了 x = 0 并进行+1操作 这时候x也是1
****************************
经过上面三步，是加了2次1，而真实运算出来的应该是+2，实际上只是加了1
这就是为什么不加锁本来应该是300000，但是实际上却小于这个数的原因
这就会产生数据安全问题
"""
mutex.release()
if __name__ == '__main__':
t1 = Thread(target=task)
t2 = Thread(target=task)
t3 = Thread(target=task)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print(x)
死锁问题
from threading import Thread,Lock
lock1 = Lock()
# lock2 = lock1 #这种情况相当于只有一把锁，
# 所以抢到了锁1之后没办法再抢锁2了，就会卡在（Thread-1 抢到了锁1）
lock2 = Lock()
class DeadLock(Thread):
def run(self):
self.task1()
self.task2()
def task1(self):
lock1.acquire()
print(f'{self.name} 抢到了锁1')
lock2.acquire()
print(f'{self.name} 抢到了锁2')
lock2.release()
print(f'{self.name} 释放了锁2')
lock1.release()
print(f'{self.name} 释放了锁1')
def task2(self):
# 这里如果抢锁2，就会出现死锁现象，就会卡在这
# lock2.acquire()
# print(f'{self.name} 抢到了锁2')
# 这里如果抢锁1，就不会出现死锁现象，会一直运行下去
# lock1.acquire()
# print(f'{self.name} 抢到了锁1')
lock2.acquire()
print(f'{self.name} 抢到了锁2')
lock1.release()
print(f'{self.name} 释放了锁1')
lock2.release()
print(f'{self.name} 释放了锁2')
for i in range(3):
t = DeadLock()
t.start()
*******死锁问题********
###两个线程
# 线程1拿到了（锁2），想要往下执行需要（锁1），
# 线程2拿到了（锁1），想要往下执行需要（锁2），
# 互相都拿到了彼此想要往下执行的必需条件，互相都不放手里的锁
递归锁
from threading import Thread,RLock
'''
递归锁 在同一个线程内可以被多次acquire
如何释放 内部相当于维护了一个计数器
也就是说同一个线程 acquire了几次
就要release几次
'''
lock1 = RLock()
lock2 = lock1
class Recursion(Thread):
def run(self):
self.task1()
self.task2()
def task1(self):
lock1.acquire()
print(f'{self.name}抢到了 锁1')
lock2.acquire()
print(f'{self.name}抢到了 锁2')
lock1.release()
print(f'{self.name}释放了 锁1')
lock2.release()
print(f'{self.name}释放了 锁2')
def task2(self):
lock1.acquire()
print(f'{self.name}抢到了 锁1')
lock2.acquire()
print(f'{self.name}抢到了 锁2')
lock1.release()
print(f'{self.name}释放了 锁1')
lock2.release()
print(f'{self.name}释放了 锁2')
for i in range(3):
t = Recursion()
t.start()
#可以正常执行，不会出现差错
信号量
from threading import Thread,currentThread,Semaphore
import time
def task():
sm.acquire()
time.sleep(2)
print(f'{currentThread().name} is running!')
sm.release()
sm = Semaphore(5) #（可以一次性发5个，信号量就是自定义最大连接数5个）
for i in range(15):
t = Thread(target=task)
t.start()
"""
会分3组，
每组5个打印出来
"""
GIL（全局解释器锁）
"""
###在Cpython解释器中有一把GIL（全局解释器锁），GIL锁本质是一把互斥锁。
导致了同一个进程下，同一时间只能运行一个进程，无法利用多核优势，同一进程
下多个线程只能实现并发不能实现并行。
为什么要有GIL？
因为Cpython自带的垃圾回收机制不是线程安全的，所以要有GIL锁。
导致了同一进程下，同一时间只能运行一个线程，无法利用多核优势。
分析：
我们有四个任务需要处理，处理方式肯定要玩出并发的效果，解决方案可以是：
方案一：开启四个进程
方案二：一个进程下，开启四个线程
"""
#******计算密集型******
#推荐使用多进程
from threading import Thread
from multiprocessing import Process
import time
def work1():
res = 0
for i in range(100000000):
res *= i
if __name__ == '__main__':
t_list = []
start = time.time()
for i in range(5):
t = Process(target=work1)
# t = Thread(target=work1())
t.start()
t_list.append(t)
for t in t_list:
t.join()
end = time.time()
print('多进程', end - start) #多进程 22.06749701499939
# print('多线程', end - start) #多线程 41.195727586746216
******IO密集型******
#推荐使用多线程
from threading import Thread
from multiprocessing import Process
import time
def task1():
x = 1+1
time.sleep(3)
if __name__ == '__main__':
t_list = []
start = time.time()
for i in range(4):
# t = Thread(target=task1)
t = Process(target=task1)
t_list.append(t)
t.start()
for t in t_list:
t.join()
end = time.time()
# print('多线程', end - start) #多线程 3.002215623855591
print('多进程', end - start) #多进程 3.8354334831237793
