python 网络并发 ：理论部分

1.今日内容大纲

1. 进程的介绍（理论部分）

2. 进程的创建以及分析

3. 获取进程的pid

4. 进程之间的隔离

1.进程的介绍(理论部分)

1.1什么是进程

一个正在被cpu执行的程序就是一个进程，一个程序可以开启多个进程。

1.2 串行、并发、并行

1.2.1 串行

程序一个一个的被执行，同一时刻cpu只能执行一个程序。

1.2.2 并行

并行是同时运行多个程序，一个cpu运行一个程序，如果4个cpu同时运行4个程序。

1.2.3 并发

伪并行，看起来像是同时运行，其实是cpu在不同的任务间来回切换。多道技术。

• 谁的效率最高？

  并行的效率最高。

• 除去并行，直说串行和并发，谁的效率高？

  如果多个任务都是计算密集型，串行的效率高。

  如果IO密集型的任务居多，并发的效率高。

1.3 阻塞、非阻塞

• 阻塞

  程序运行中由于某种原因（input，accept等）使得程序夯住，等待一段时间之后（获取到了结果之后），再继续运行。如果阻塞了，操作系统会将cpu从此任务中切换到执行其他的任务。

• 非阻塞

  程序运行开始至结束中途无需等待结果（停住）。

1.4 进程的创建

无论哪一种，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的：（言外之意，一个进程的创建一定是基于一个父进程）

• 在UNIX中该系统调用是：fork，fork会创建一个与父进程一模一样的副本，二者有相同的存储映像、同样的环境字符串和同样的打开文件（在shell解释器进程中，执行一个命令就会创建一个子进程）

• 在windows中该系统调用是：CreateProcess，CreateProcess既处理进程的创建，也负责把正确的程序装入新进程。

关于创建的子进程，UNIX和windows

相同的是：进程创建后，父进程和子进程有各自不同的地址空间（多道技术要求物理层面实现进程之间内存的隔离），任何一个进程的在其地址空间中的修改都不会影响到另外一个进程。

不同的是：在UNIX中，子进程的初始地址空间是父进程的一个副本，提示：子进程和父进程是可以有只读的共享内存区的。但是对于windows系统来说，从一开始父进程与子进程的地址空间就是不同的。

1.5 进程的三个状态

进程的三个状态：运行，阻塞，就绪。

2.python的并发编程之多进程

2.1创建进程的两种方式

• 引子

  我们之前写的那些项目，模拟博客园，ATM，教务管理系统等等都是一个程序，只有socket才是开启了多个进程进行操作。

• 函数式开启进程的方式

  

   from multiprocessing import Process
   ​
   ​
   def task(a):
       print('in task')
       return a + 1
   ​
   ​
   if __name__ == '__main__':  # windows系统下，开启多进程一定要配置这行代码。
   ​
       p1 = Process(target=task, args=(100,))  # 创建一个子进程对象
       p1.start()  # 通知操作系统在内存中开辟一个子进程空间，将主进程所有的资源深copy一份放置到子进程空间中
       print('=====主')
   ​
   ​
   ​
   # import time
   # a = 1
   # b = 2
   # print(a + b)
   # time.sleep(2)
   # print(666)

  • 为什么主进程先执行，而子进程后执行？

    当p.start执行时，内存中马上开辟一个空间，创建一个子进程，此时cpu对应的就是在主子进程之间选择切换，由于子进程还需要加载数据等，遇到了阻塞，所以先执行主进程，这也说明了开启进程的开销相对较大。

• 面向对象开启进程方式

   # from multiprocessing import Process
   # import time
   #
   # def task(a):
   #     print('in task')
   #     return a + 1
   #
   #
   # if __name__ == '__main__':  # windows系统下，开启多进程一定要配置这行代码。
   #
   #     p1 = Process(target=task, args=(100,))  # 创建一个子进程对象
   #     p1.start()  # 通知操作系统在内存中开辟一个子进程空间，将主进程所有的资源深copy一份放置到子进程空间中
   #     time.sleep(1)
   #     print('=====主')
   ​
   ​
   ​
   # import time
   # a = 1
   # b = 2
   # print(a + b)
   # time.sleep(2)
   # print(666)
   ​
   ​
   from multiprocessing import Process
   import time
   ​
   class MyProcess(Process):
   ​
       def __init__(self, name):
           super().__init__()
           self.name = name
   ​
       def run(self):  # 子进程的任务
           print(f'{self.name}开始运行了')
           time.sleep(2)
           print(f'{self.name}子进程结束了')
   ​
   ​
   if __name__ == '__main__':
   ​
       p1 = MyProcess('玮哥')
       p1.start()
       time.sleep(1)
       print('=====主')

  注意：在windows中Process()必须放到# if name == 'main':下

   Since Windows has no fork, the multiprocessing module starts a new Python process and imports the calling module. 
   If Process() gets called upon import, then this sets off an infinite succession of new processes (or until your machine runs out of resources). 
   This is the reason for hiding calls to Process() inside
   ​
   if __name__ == "__main__"
   since statements inside this if-statement will not get called upon import.
   由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 
   如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 
   这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。
   ​
   详细解释