并发通信与并发池

嫌水摸鱼

于 2022-09-28 14:00:21 发布

阅读量249

点赞数

文章标签： python websocket pycharm

本文链接：https://blog.csdn.net/qh075/article/details/127088022

版权

一：进程和线程相互通信

进程之间有通信隔离，但是线程与线程之间没有，如果线程之间处理大量的数据的时候会出现资源抢占的情况

解决进程之间通信隔离方法：开辟一个公共空间

 mg = multiprocessing.Manager()  # 创建一个公共服务器进程
 li = mg.list()  # 开辟一个列表空间

 import multiprocessing
 
 var = 18
 
 
 def func(list1):
     global var
     var += 1
     print('inner', var)
     list1.append(var)
     return var
     # list1.extend([1, 2, 3, 4])
 
 
 if __name__ == '__main__':
     mg = multiprocessing.Manager()  # 创建一个公共服务器进程
     li = mg.list()  # 开辟一个列表空间
     # print(li)
     p1 = multiprocessing.Process(target=func, args=(li,))
     p1.start()
     p1.join()  # 等待子任务结束
     # print('outer', var)
     # print('outer',li)
     for i in li:
         print("outer",i)

1.线程资源抢占

 import threading
 var = 100
 
 
 def func1():
     global var
     for i in range(1000000):
         var += 1
 
 
 def func2():
     global var
     for i in range(1000000):
         var -= 1
 
 
 if __name__ == '__main__':
     t1 = threading.Thread(target=func1)
     t2 = threading.Thread(target=func2)
     t1.start()
     t2.start()
     t1.join()
     t2.join()
     print(var)

2.解决资源抢占

互斥锁

 互斥锁：对共享数据进行锁定，保证同一个时刻只能有一个线程去操作
 
 注意：互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁

互斥锁的使用

threading模块中定义了lock变量，这个变量本质上就是一个函数，通过调用这个函数可以获得一把互斥锁

互斥锁使用步骤

 # 创建锁
 mutex = threading.Lock()
 
 # 上锁
 mutex.acquire()
 
 # 释放锁
 mutex.release()

代码实现

 import threading
 var = 100
 
 # 创建互斥锁
 lock = threading.Lock()
 
 
 def func1():
     global var
     lock.acquire() # 上锁
     for i in range(1000000):
         var += 1
     lock.release() # 释放锁
 
 
 def func2():
     global var
     lock.acquire()
     for i in range(1000000):
         var -= 1
     lock.release()
 
 
 if __name__ == '__main__':
     t1 = threading.Thread(target=func1)
     t2 = threading.Thread(target=func2)
     t1.start()
     t2.start()
     t1.join()
     t2.join()
     print(var)

执行结果：

说明：

通过执行结果可以看出互斥锁能够保证多个线程访问共享数据不会出现数据错误问题

小结：

互斥锁的作用就是保证同一个时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题
使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
使用互斥锁会影响代码的执行效率，多任务改成了单任务执行
互斥锁如果没有使用好容易出现死锁的情况

死锁

 死锁：一直等待对方释放锁的情景就是死锁

死锁的结果

会造成应用程序的停止响应，不能再处理其它的任务了

死锁实例代码：

 import threading
 import time
 
 # 需求:根据下标去取值，保证同一个时刻只能有一个 线程去取值
 
 # 创建互斥锁
 lock = threading.Lock()
 
 
 def get_value(index):
     # 上锁
     lock.acquire()
     my_list = [3, 4, 5, 6]  # 0,1,2,3
     # 判断下标释放越界
     if index >= len(my_list):
         print("下标越界", index)
         return
     # 根据下标取值
     value = my_list[index]
     print(value)
     time.sleep(0.2)
     # 释放锁
     lock.release()
 
 
 if __name__ == '__main__':
     # 模拟大量线程去执行去取值的操作
     for i in range(30):
         # 每循环一次创建一个子线程
         sub_thread = threading.Thread(target=get_value, args=(i,))
         # 启动线程执行任务
         sub_thread.start()

避免死锁

在合适的地方释放锁

 import threading
 import time
 
 # 需求:根据下标去取值，保证同一个时刻只能有一个 线程去取值
 
 # 创建互斥锁
 lock = threading.Lock()
 
 
 def get_value(index):
     # 上锁
     lock.acquire()
     my_list = [3, 4, 5, 6]  # 0,1,2,3
     # 判断下标释放越界
     if index >= len(my_list):
         print("下标越界", index)
         # 取值不成功，也需要释放互斥锁，不要影响后面的线程去取值
         # 当下标越界需要释放锁，让后面的线程还可以取值
         lock.release()
         return
     # 根据下标取值
     value = my_list[index]
     print(value)
     time.sleep(0.2)
     # 释放锁
     lock.release()
 
 
 if __name__ == '__main__':
     # 模拟大量线程去执行去取值的操作
     for i in range(30):
         # 每循环一次创建一个子线程
         sub_thread = threading.Thread(target=get_value, args=(i,))
         # 启动线程执行任务
         sub_thread.start()

小结

使用互斥锁的时候需要注意死锁的问题，要在合适的地方注意释放锁
死锁一旦产生就会造成应用程序的停止响应，应用程序无法再继续往下执行了。