进程

代码创建进程

• 创建进程的方式有两种：
   1. 鼠标双击程序桌面图标
   2. 代码创建
• 创建进程的本质其实是在内存空间中申请一份内存空间去执行程序代码

代码创建进程

from multiprocessing import Process
import time
# 方式一(直接通过子进程的方式):
      def task(username):
          print('子进程开始', username)
          time.sleep(2)
          print('子进程结束', username)
      if __name__ == '__main__':
          p = Process(target=task, args=('oliver', ))  # 创建进程
          p.start()  # 提起进程
          print('主进程')  # 先执行主进程
'''
强调:不同的操作系统创建进程的要求不一样
    在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
    否则会直接报错 因为在无限制创建进程
    在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
'''

# 方式二（通过类的方式，自定义类内方法，创建进程对象）:
      class Myprocess(Process):
          def __init__(self, username):
              self.username = username
              super().__init__()
          def run(self):
              print('子进程执行开始', self.username)
              time.sleep(2)
              print('子进程执行结束', self.username)
      if __name__ == '__main__':
          p = Myprocess('oliver')
          p.start()
          print('主进程')

进程实现并发

将与客户端通信的代码封装成函数。之后的每一个客户端访问时就建立一个进程专门用改该用户端与服务端的交互

# 服务端
      import socket
      from multiprocessing import Process
      def get_server():
          server = socket.socket()
          server.bind(('127.0.0.1', 11000))
          server.listen(5)
          return server
      # 将服务客户端的代码封装成函数(通信代码)
      def communicate(sock):
          while True:
              data = sock.recv(1024)
              print(data.decode('utf8'))
              sock.send('回复的信息'.encode('utf8'))
      if __name__ == '__main__':
          server = get_server()
          while True:
              sock, addr = server.accept()
              p = Process(target=communicate, args=(sock,))
              p.start()
# 客户端
      import socket
      client = socket.socket()
      client.connect(('127.0.0.1', 11000))
      while True:
          msg = input('请输入要发送的信息>>>>:').strip()
          client.send(msg.encode('utf8'))
          data = client.recv(1024)
          print(data.decode('utf8'))

join方法

join方法的主要作用就是让主进程等待子进程代码执行完毕再执行

      from multiprocessing import Process
      import time
      def task(name, n):
          print(f'{name}正在执行')
          time.sleep(n)
          print(f'{name}执行结束')
      if __name__ == '__main__':
          p1 = Process(target=task, args=('oliver', 1))
          p2 = Process(target=task, args=('kevin', 2))
          p3 = Process(target=task, args=('tony', 3))
# 第一种join用法
          # start_time = time.time()
          # p1.start()
          # p2.start()
          # p3.start()
          # p1.join()
          # p2.join()
          # p3.join()
          # end_time = time.time() - start_time
          # print(end_time)  # 3.129368543624878
# 第二种join用法
          start_time = time.time()
          p1.start()
          p1.join()
          p2.start()
          p2.join()
          p3.start()
          p3.join()
          end_time = time.time() - start_time
          print(end_time)  # 6.310400724411011

两种方法的直观上的差别是执行时间的差别。不过其实时间的不同是因为代码的运行时间以及等待时间的处理不同。如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和

进程间数据默认隔离

各进程所占据的内存空间是默认独立的，所以数据彼此之间无干扰

      from multiprocessing import Process
      money = 999
      def task():
          global money
          money = 1234
          print('子进程', money)  # 子进程 1234
      if __name__ == '__main__':
          p = Process(target=task)
          p.start()
          print('父进程', money)  # 父进程 999

子进程更改全剧不可变数据，只是在子进程的内存空间内进行了更改，全局的数据以及父进程的数据并未改变

进程对象属性和方法

查看进程号

两种方法：
 1. multiprocessing包里的 current_process方法
 2. os模块的getpid关键字

      from multiprocessing import Process, current_process
      import os
      def task(username):
          print('子进程开始', username)
          print('子进程结束', username)
          print(current_process().pid)  # 33120  # 获取当前进程号
          print(os.getpid())  # 33120  获取当前进程号
          print(os.getppid())  # 38640  获取父进程号
      if __name__ == '__main__':
          p = Process(target=task, args=('oliver', ))  # 创建进程
          p.start()  # 提起进程
          print('主进程')  # 先执行主进程
          print(current_process().pid)  # 38640  # 获取当前进程号
          print(os.getpid())  # 38640

杀子进程terminate

判断子进程是否存活is_alive

      from multiprocessing import Process
      import time
      def task(username):
          print('子进程开始', username)
          time.sleep(2)
          print('子进程结束', username)
      if __name__ == '__main__':
          p = Process(target=task, args=('oliver', ))  # 创建进程
          p.start()  # 提起进程
          print(p.is_alive())  # True
          time.sleep(1)
          p.terminate()  # 杀死当前子进程
          time.sleep(3)
          # p.join()
          print(p.is_alive())  # False
          print('主进程')  # 先执行主进程

僵尸进程与孤儿进程

僵尸进程

为什么主进程默认需要等待子进程结束才会结束？
   所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
   还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)
   这些信息会被主进程回收(僵尸彻底死了)
   1. 主进程正常结束
    2. 调用join方法

孤儿进程

子进程存活着 父进程意外死亡
   子进程会被操作系统自动接管(儿童福利院)

守护进程

守护进程是指子进程守护父进程：在父进程结束时，子进程必须结束

      from multiprocessing import Process
      import time
      def task():
          print('子进程开始执行')
          time.sleep(2)
          print('子进程执行结束')
      if __name__ == '__main__':
          p = Process(target=task)
          p.daemon = True  # 将子进程设置为守护进程，父进程结束的时候，子进程一定结束
          p.start()
          time.sleep(1)
          print('主进程执行并结束')

互斥锁

多进程操作同一数据的时候，限制单一时刻只能有一个进程对该数据进行操作。也就是说,异步的进程，在操作某些数据的时候，必须严格按照串行的规则进行操作
  比如:春运时期抢票问题,同一时刻很多人抢同一张票的时候只能有一个人抢到
  目的:防止信息安全问题的产生

抢票的简单实现

      from multiprocessing import Process
      import time
      import random
      import json
      def search(name):
          with open(r'res_ticket', 'r', encoding='utf8') as f:
              data = json.load(f)
              print(f'用户{name}查询余票剩余>>>: %s' % data.get('ticket_num'))
      def buy(name):
          with open(r'res_ticket', 'r', encoding='utf8') as f:
              data = json.load(f)
          res = data.get('ticket_num')
          time.sleep(random.randint(1, 2))
          if res > 0:
              data['ticket_num'] -= 1
              with open(r'res_ticket', 'w', encoding='utf8') as f:
                  json.dump(data, f)
              print(f'用户{name}抢票成功')
          else:
              print('余票不足, 抢票失败')
      def run(name):
          search(name)
          buy(name)
      if __name__ == '__main__':
          for i in range(1, 11):
              p = Process(target=run, args=('用户：%s' % i))
              p.start()

结果

此时出现了一张票被十个人抢到的问题。这很明显是有问题的。主要是由于在对数据进行操作的时候，也是采用异步的方式进行操作的，也就是说，这几个在购票的时候得到的数据都是有一张余票，才造成这种局面。为了解决这个问题，我们限制同时操作数据的人数就行

互斥锁

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

      from multiprocessing import Process, Lock
      import time
      import random
      import json
      def search(name):
          with open(r'res_ticket', 'r', encoding='utf8') as f:
              data = json.load(f)
              print(f'{name}   查询余票剩余>>>: %s' % data.get('ticket_num'))
      def buy(name):
          with open(r'res_ticket', 'r', encoding='utf8') as f:
              data = json.load(f)
          res = data.get('ticket_num')
          time.sleep(random.randint(1, 2))
          if res > 0:
              data['ticket_num'] -= 1
              with open(r'res_ticket', 'w', encoding='utf8') as f:
                  json.dump(data, f)
              print(f'{name}抢票成功')
          else:
              print('余票不足, 抢票失败')
      def run(name, mutex):
          search(name)
          mutex.acquire()  # 抢锁
          buy(name)
          mutex.release()  # 放锁
      if __name__ == '__main__':
          mutex = Lock()
          for i in range(1, 11):
              p = Process(target=run, args=('用户%s:' % i, mutex))
              p.start()