Python之多进程

进程基础(操作系统中的概念)
进程它是操作系统总最重要的概念，线程也是

进程和线程都是有操作系统来调度使用的，我们程序员是不能控制的

# 进程和程序是两码事、完全不一样

      程序：其实一个死的东西、一堆代码就是程序，它也没有生命周期

      进程：它是有生命周期的，这个任务做完，进程就不存在了

              # 程序就是流程. 做菜的过程就是进程，

                 厨师就是线程，谁干活谁就是线程，做菜完，进程就不存在了

# 一个进程中至少要有一个线程，可以有多个线程

# 协程就是程序员级别的，协程的调度它就是有我们程序员自己来调度的

          进程 >>> 线程  >>> 协程

          他们三个消耗资源的对比：进程 >>> 线程 >>> 协程

# 单个CPU一次只能运行一个任务，打开浏览器的过程就是进程

进程调度算法(四种算法)
# CPU的工作机制：

         1. 遇到I/O的时候，CPU会交出执行权限
         2. 当CPU遇到耗时比较长的时候，也会自动交出执行权限，切换到其他任务

#  I/O密集型：会被时间所阻塞，不会占用大量的CPU资源，比如sleep(3)

   计算密集型：没有时间的大量消耗，不占用大量的时候，会占用大量的CPU资源

for i in range(10000000):
      i+=1
一、先来先服务调度算法
二、短作业优先调度算法
三、时间片轮转法（选时间合适的）
四、多级反馈队列

进程的并行和并发概念
并行：统一时刻同时运行

并发：一段时间内看起来是同时运行

          CPU是单核时，同一时刻能不能做到同时执行多个任务，看上去是，来回切换

          CPU4核，执行2个任务，派哪两个核是由操作系统做

"""面试题：你对高并发有什么见解? 聊聊高并发? 你如何解决?"""

同步异步阻塞和非阻塞
# 老师：

       同步：每一次的运行都要依赖于上一步的结果       # 电话不挂，查到告诉
       异步：每次的运行结果不依赖于上次的结果          #  先挂，查到后再打电话告诉

# 我：

        阻塞： # 电话不挂，一直等老师消息
       非阻塞：  # 先干自己的事，没有再打电话给老师询问消息

异步+非阻塞 # 是效率最高的
                    同步+阻塞   # 是效率最低的 

如何开启进程
from multiprocessing import Process
 
def task():
    with open('a.txt', 'w', encoding='utf-8') as f:
        f.write('helloworld')
 
if __name__ == '__main__':
    p = Process(target=task)  #   实例出来一个进程类， 让这个进程执行task任务
    p.start()    # 真正的开启进程
# 开启一个进程来执行task任务，真正执行的是线程，进程里面至少有一个线程

# 操作系统开启进程

Process类的参数
进程的几个属性：1、进程名   2、进程号pid   kill

# 查看就进程名称      print( p.name)

# 改进程名字

p.name = '这是新的进程名'
print(p.name)  # 这是新的进程名
# 传参

from multiprocessing import Process
import time
 
def task(name, age, gender):
    time.sleep(3)
    print("子进程的代码")
 
if __name__ == '__main__':
    # 只是通知操作系统去开进程，有一定时间，开启进程其实消耗很大
    p = Process(target=task, name='process-2')   # 子进程
    p.start()  # 启动进程
# 查看进程号：print(p.pid) # process id

task任务里都是子进程，其余是主进程

           p.start()  # 真正的开启进程

           p.terminate() # 杀死进程，结束任务

           print(p.is_alive())   # True 看进程是否还在

           p.join() # 等待子进程的代码全部执行完毕，在走主进程的

单进程

如何开启多进程
多进程就意味着可以同时做多个任务

from multiprocessing import Process
import time
 
def task(name):
    with open('a.txt', 'a', encoding='utf-8') as f:
         f.write('helloworld')
 
if __name__ == '__main__':
    for i in range(5):     # 执行5次
        p=Process(target=task, kwargs={'name':'kevin'})
        p.start()    
# 理论上可以一直开进程，但是需要考虑资源的消耗情况

       # 先执行主进程，再执行子进程

多进程中，想先执行子进程再主进程，p.join()，不能加在for循环中，不然是5秒

from multiprocessing import Process
import time
 
def task(name):
    print("子进程")
    time.sleep(1)
 
if __name__ == '__main__':
    start_time = time.time()
    ll = []
    for i in range(10):
        p=Process(target=task, kwargs={'name':'kevin'})
        p.start()
        ll.append(p)
 
    for j in ll:        # 小的高并发情况，双11同时涌进大量客户
        j.join()
    print("主进程, 总时间：", time.time() - start_time)

基于TCP协议的高并发程序
一个服务端不能够同时给多个客户端发送消息

import socket  # python提供的socket模块
 
def task(conn):
    while True:
        try:
            data = conn.recv(1024)  # 括号里面写的是接收的字节数，最多接收1024个字节
            if len(data) == 0:
                continue
            print(data)  # 还是bytes类型
            conn.send(data.upper())    # 服务端开始给客户端也发送一个数据
        except Exception as e:
            print(e)
            break
    conn.close()
 
 
from multiprocessing import Process
 
if __name__ == '__main__':
    server = socket.socket()  # 默认是TCP协议
    server.bind(('127.0.0.1', 8001))  # 服务端绑定一个地址
    server.listen(1)  # 监听，半连接池
    print('服务端正在准备接收客户端消息：')
    while True:
        conn, client_addr = server.accept()  # 接收,  程序启动之后，会在accept这里夯住，阻塞
        p = Process(target=task, args=(conn,))
        p.start()