并发编程2

内容概要

---

• 代码创建进程
• join方法
• 进程间数据默认隔离
• 进程对象相关属性和方法
• 僵尸进程与孤儿进程(纯理论)
• 守护进程
• 互斥锁(重要)

---

内容详情

---

代码创建进程

"""
创建进程的方式:
    1.鼠标双击桌面一个应用图标
    2.代码创建	
创建进程的本质:在内存中申请一块内存空间用于运行相应的程序代码
"""

# 第一种创建进程的方式
  from multiprocessing import Process
  import time
 
 
  def task(name):
      print('%s is running' % name)
      time.sleep(3)
      print('%s is over' % name)
 
 
  if __name__ == '__main__':
      p = Process(target=task, args=('jason',))  # 创建一个进程对象
      p.start()  # 告诉操作系统创建一个新的进程
      print('主进程')
"""
强调:不同的操作系统创建进程的要求不一样
     在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中 否则会直接报错 因为在无限制创建进程
     在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
"""

# 创建进程的第二种方式
from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()
    def run(self):
        print('你好啊 小姐姐',self.username)
        time.sleep(3)
        print('get out!!!',self.username)
if __name__ == '__main__':
    p = MyProcess('tony')
    p.start()
    print('主进程')

进程实现并发

思考:如何让TCP服务端实现并发的效果
"""
将与客户端通信的代码封装成一个函数 
之后每来一个客户端就创建一个进程专门做交互
"""
# 服务端
  import socket
  from multiprocessing import Process


  def get_server():
      server = socket.socket()
      server.bind(('127.0.0.1', 8080))
      server.listen(5)
      return server


  def talk(sock):  # 将服务客户端的代码封装成函数(通信代码)
      while True:
          data = sock.recv(1024)
          print(data.decode('utf8'))
          sock.send(data.upper())


  if __name__ == '__main__':
      server=get_server()
      while True:
          sock, addr = server.accept()
          p = Process(target=talk, args=(sock, ))
          p.start()

# 客户端1
  import socket

  client = socket.socket()
  client.connect(('127.0.0.1', 8080))

  while True:
      client.send(b'hello big baby~')
      data = client.recv(1024)
      print(data.decode('utf8'))

# 客户端2
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'I miss you baby')
    data = client.recv(1024)
    print(data.decode('utf8'))

join方法

# join方法让主进程代码等待子进程代码运行完毕再执行
  1.join方法的简单使用
  2.如何真正理解等待的过程

  from multiprocessing import Process
  import time


  def task(name, n):
      print(f'{name} is running')
      time.sleep(n)
      print(f'{name} is over')


  if __name__ == '__main__':
      p1 = Process(target=task, args=('jason', 1))
      p2 = Process(target=task, args=('tony', 2))
      p3 = Process(target=task, args=('kevin', 3))
      start_time = time.time()
      p1.start()
      p2.start()
      p3.start()
      p1.join()
      p2.join()
      p3.join()
      end_time = time.time() - start_time
      print('主进程', f'总耗时:{end_time}')  # 主进程 总耗时:3.015652894973755
      # 如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和
    
"""
需求:想让p.start()之后的代码 等待子进程全部运行结束之后再打印
    1.sb(sweet baby)做法:直接sleep
        肯定不行 因为子进程运行的时间不可控
    2.join方法
        针对多个子进程的等待一定要理解!!!
"""

进程间数据默认隔离

# 内存可以看成是有很多个小隔间组成的 彼此不干扰
  from multiprocessing import Process

  money = 999


  def task():
      global money  # 局部修改全局不可变类型
      money = 666


  if __name__ == '__main__':
      p = Process(target=task)
      p.start()
      p.join()  # 确保子进程代码运行结束再打印money
      print(money)
 
"""默认隔离  但是可以通过一些技术打破"""

进程对象相关属性和方法

"""
进程号如何查看（命令行）
windows:    tasklist    结果集中PID
mac:        ps -ef
杀死进程（命令行）
windows      taskkill关键字
mac/linux    kill关键字
"""
1.查看进程号的方法（代码）
  1.1.current_process函数
      from multiprocessing import Process, current_process
      current_process().pid
      # 获取进程号的用处之一就是可以通过代码的方式管理进程
  1.2.os模块
      os.getpid()   # 获取当前进程的进程号
      os.getppid()  # 获取当前进程的父进程号
2.杀死子进程（代码 ）
  p.terminate()  # 告诉操作系统杀死子进程需要反应时间再判断子进程是否存活
  time.sleep(0.1)
3.判断子进程是否存活
  is_alive()  # 布尔值

僵尸进程与孤儿进程(纯理论)

僵尸进程
  # 为什么主进程默认需要等待子进程结束才会结束
    所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
    还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)

    这些信息会被主进程回收(僵尸彻底死了)
    1.主进程正常结束
    2.调用join方法
  
孤儿进程
  # 子进程存活着 父进程意外死亡
    子进程会被操作系统自动接管(儿童福利院)

守护进程

"""
守护即死活全部参考守护的对象
      对象死立刻死
"""
from multiprocessing import Process
import time


def task(name):
    print(f'大内总管:{name}正常活着')
    time.sleep(3)
    print(f'大内总管:{name}正常死了')

if __name__ == '__main__':
    p = Process(target=task, args=('赵公公',))
    # 必须写在start前面
    p.daemon = True  # 将子进程设置为守护进程:主进程结束 子进程立刻结束
    p.start()
    print('皇帝Jason寿终正寝')

互斥锁(重要)

"""
每逢节假日抢票
    手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了
    之后回到查询页面发现确实显示没有票了

    上午10:00打开买票软件查看票数 系统给你发过来的是10:00对应的数据
    只要你页面不刷新不点击下一步 那么页面数据永远展示的是10:00的
"""
# 代码模拟抢票(有问题)
  ticket_data.json（数据文件）
  {"ticket_num": 1}


  import json
  from multiprocessing import Process
  import time
  import random


# 查票
  def search(name):
      with open(r'ticket_data.json', 'r', encoding='utf8') as f:
          data = json.load(f)
      print(f'{name}查询当前余票:%s' % data.get('ticket_num'))


# 买票
  def buy(name):
      '''
      点击买票是需要再次查票的 因为期间其他人可能已经把票买走了
      '''
      # 1.查票
      with open(r'ticket_data.json', 'r', encoding='utf8') as f:
          data = json.load(f)
      time.sleep(random.randint(1, 3))
      # 2.判断是否还有余票
      if data.get('ticket_num') > 0:
          data['ticket_num'] -= 1
          with open(r'ticket_data.json', 'w', encoding='utf8') as f:
              json.dump(data, f)
          print(f'{name}抢票成功')
      else:
          print(f'{name}抢票失败 没有余票了')


  def run(name):
      search(name)
      # mutex.acquire()
      buy(name)
      # mutex.release()

# 模拟多人同时抢票
  if __name__ == '__main__':
      # mutex = Lock()
      for i in range(1, 10):
          p = Process(target=run, args=('用户:%s' % i,))
          p.start()

###########################################################
当多个进程操作同一份数据的时候会造成数据的错乱！！！
这个时候需要加锁处理(互斥锁)
    将并发变成串行 牺牲了效率但是保证的数据的安全
 
互斥锁并不能轻易使用 容易造成死锁现象
互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率
###########################################################
查票可以一次性给所有人看 但是买票环节必须'排队'>>>:互斥锁

from multiprocessing import Process, Lock
mutex = Lock()  # 互斥锁只能在主进程中产生一把 交给多个子进程用
mutex.acquire()  # 抢锁
mutex.release()  # 放锁
ps:我们以后在编程生涯中几乎不会自己操作锁 理解原理即可
  
"""
锁相关知识
    行锁:针对行数据加锁 同一时间只能一个人操作
    表锁:针对表数据加锁 同一时间只能一个人操作
锁的应用范围很广 但是核心都是为了保证数据的安全!!!
"""