3、并发编程

1、并发编程想换

2、并发编程理论基础

3、基于tcp/udp并发相关

4、开启进程

5、进程内存的空间隔离

6、进程对象相关方法

1、并发编程相关：

  进程：进程指的就是程序运行的过程，是一个动态的概念
  程序：程序就是一系列的代码文件，是一个静态的概念
  
  进程也可以说成是操作系统干活的过程，就是操作系统控制硬件来运行应用程序的过程

  进程是操作系统最核心的概念，研究进行就是在研究操作系统

2、学习必备的理论基础：

  #一 操作系统的作用：
      1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
      2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

  #二 多道技术：
      1.产生背景：针对单核，实现并发
      ps：
      现在的主机一般是多核，那么每个核都会利用多道技术
      有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
      cpu中的任意一个，具体由操作系统调度算法决定。

      2.空间上的复用：如内存中同时有多道程序
      3.时间上的复用：复用一个cpu的时间片
         强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
              才能保证下次切换回来时，能基于上次切走的位置继续运行

3.1、💣💣💣💣💣💣基于tcp并发💣💣💣💣💣💣

基于tcp的并发服务端

  import socketserver
  class MyRequestHandler(socketserver.BaseReqestHandler):
        def handle(self):
              while True：
                    try:
                          data = self.request.recv(1024)
                          if len(data) == 0:
                                break
                          print(data)
                          self.request.send(data.upper())
                    except Exception:
                          break
              self.request.close()
  server = socletserver.ThreadingTCPServer(('127.0.0.1',8080'),MyRequestHandler,bind_and_activate = True)
  server.serve_forever()

基于tcp的并发客户端

  iimport socket

  phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  # 流式协议
  phone.connect(('127.0.0.1',8080))
  while True:
      msg = input('>>>: ').strip()
      if len(msg) == 0:
          continue
      phone.send(msg.encode('utf-8'))
      data = phone.recv(1024)
      print(data.decode('utf-8'))
  phone.close()

3.2、💣💣💣💣💣💣基于udp并发💣💣💣💣💣💣

基于udp的并发服务端

  import socketserver
  class MyRquestHandler(socketserver.BaseRequestHandler):
        def handle(self):
              data,server = self.request
              server.sendto(data.upper(),self.client_address)

  server = socketserver.ThreadingUDPServer(('127.0.0.1',9999),MyRquestHandler)
  server.serve_forever()

基于udp的并发客户端

  from socket import *
  client = socket(AF_INET,SOCK_DGRAM)

  while True:
      msg = input('>>>>>:').strip()
      client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
      res,server_addr = client.recvfrom(1024)
      print(res.decode('utf-8'))

4、💣💣💣💣💣💣开启进程💣💣💣💣💣💣

开启进程的方式一、

  import os 
  from multiprocessing import Process
  import time
  def task(n):
        print('父进程%s 当前进程%s 开始'%s(os.getppid(),os.getpid()))
        time.sleep(n)
        print('父进程%s 当前进程%s 结束'%s(os.getppid(),os.getpid()))
  if __name__ == '__main__':
        p = Process(target = task,args=(3,))
        p.start()
        print('主',os.getpid())

开启进程的方式二、自定义类 ）

  import os 
  from multiprocessing import Process
  import time
  class Myprocess(Process):
        def __init__(self,n):
              super().__init__()
              self.n = n
        def run(self)：
              print('父进程%s 当前进程%s 开始'%s(os.getppid(),os.getpid()))
              time.sleep(n)
              print('父进程%s 当前进程%s 结束'%s(os.getppid(),os.getpid()))
  if __name__ == '__main__':
        p = Myprocess(3)
        p.start()
        print('主',os.getpid())

5、✈✈✈✈✈✈✈✈进程内存的空间隔离✈✈✈✈✈✈✈✈

  from multiprocessing import Process
  
  count = 999
  def task():
        global conut
        count = 0
  if __name__ == '__main__':
        p = Process(target = task)
        p.start()       # 通知操作系统开启进程
        p.jion()        # 主程序 等待子程序运行完
        print('主',count)    # 999

6、🚗🚗🚗🚗🚗🚗进程对象的相关方法🚗🚗🚗🚗🚗🚗

  import time
  import os
  from multiprocessing import Process
  
  count = 999
  def task(n):
        print(os.getpid())
        time.sleep(n)
  if __name__ == '__main__':
        p1 = Process(target=task,args=(3,))
        p2 = Process(target=task,args=(2,))
        p3 = Process(target=task,args=(1,))
        start = time.time()
        p1.start()  
        p2.start()
        p3.start() 
        p1.join()
        p2.join()
        p3.join()
        end = time.time()
        print(end -time)    # 3.多 子程序 p1,p2,p3 异步运行，最长3秒，得出时间是3秒+切换时间