进程

进程的三状态图
    就绪  运行  阻塞

进程的调度算法
    给所有的进程分配资源或者分配cpu使用权的一种方法
    短作业优先
    先来先服务
    多级反馈算法
        多个任务队列，优先级从高到低
        新来的任务总是优先级最高的
        每一个新任务几乎会立即获得一个时间片时间
        执行完一个时间片之后就会降到下一级队列中
        总是优先级高的任务都执行完才执行优先级低的队列
        并且优先级越高时间片越短

"""
多元的处理进程模块
"""

from multiprocessing import Process
import os

def func(name):
    print(os.getpid(), os.getppid(), name)    # 进程id  父进程id


if __name__ == "__main__":
    # 只会在主进程中执行的所有代码都放在__name__ == "__main__"下
    print("main:", os.getpid(), os.getppid())
    p = Process(target=func, args=("aaa",))
    p.start()   # 开启子进程



"""
在window中，一定要加__name__ == "__main__"，因为window执行脚本是导入方式
在linux和mac系统子进程是直接复制

子进程传递参数
    args=("aaa",) 必须是元组
    
不能获取到子进程的返回值

可以开启多个子进程

join
    阻塞，必须等到该进程执行完毕才继续执行代码
    
同步阻塞：join
异步非阻塞：start

多进程之间的数据是隔离的

"""

数据共享

from multiprocessing import Process,Manager,Lock

def change_dic(dic,lock):
    with lock:
        dic['count'] -= 1


if __name__ == "__main__":
    lock = Lock()
    m = Manager()
    dic = m.dict({"count": 100})
    p1 = []
    for i in range(100):
        p = Process(target=change_dic, args=(dic, lock))
        p.start()
        p1.append(p)
    for p in p1:
        p.join()
    print(dic)

 

守护进程

import time
from multiprocessing import Process

def son1():
    while True:
        print("in son1")
        time.sleep(1)

def son2():
    for i in range(10):
        print("in son2")
        time.sleep(1)

if __name__ == "__main__":
    p = Process(target=son1)
    p.daemon = True     # 表示设置p是一个守护进程
    p.start()
    p1 = Process(target=son2)
    p1.start()
    time.sleep(5)
    print("end main")
    p1.join()   # 等待p1结束之后才结束

"""
主进程会等待所有的子进程结束，是为了回收资源
守护进程会等待主进程代码结束之后在结束，而不是等待整个主进程结束
"""

 

进程锁

from multiprocessing import Lock, Process
import time

def func(i, lock):
    lock.acquire()  # 拿钥匙
    print(f"被锁起来的代码{i}")
    time.sleep(1)
    lock.release()  # 还钥匙       可以用with lock: 代替拿钥匙 还钥匙，并且在此基础上做一些一场处理
if __name__ == "__main__":
    lock = Lock()
    for i in range(10):
        p = Process(target=func, args=(i, lock))
        p.start()

 

进程队列

"""
队列之间数据隔离
进程之间通信（IPC）  Inter Process communication
    基于文件：同一台机器上的多个进程之间通信
        基于socket的文件级别的通信来完成数据传递的
            Queue 队列    from multiprocessing import Queue
    基于网络：同一台机器或者多台机器上的多进程间通信
        第三方工具（消息中间件）
            memcache
            redis
            rabbitmq
            kafka



生产者消费者模型
    爬虫
    分布式操作：selery
    本质：就是让生产数据和消费者数据的效率达到平衡且最大化的效率
"""

'''from multiprocessing import Queue, Process

def son(q):
    q.put("hello")

if __name__ == "__main__":
    q = Queue()
    p = Process(target=son, args=(q, ))
    p.start()
    print(q.get())'''

'''from multiprocessing import Queue, Process
import random
import time

def consumer(q):    # 消费者：通常渠道数据之后还要进行某些操作
    for i in range(10):
        print(q.get())
def producer(q):    # 生产者：通常在放数据之前要先通过某些代码来获取数据
    for i in range(10):
        time.sleep(random.random())
        q.put(i)

if __name__ == "__main__":
    q = Queue()
    c = Process(target=consumer, args=(q, ))
    p = Process(target=producer, args=(q, ))
    c.start()
    p.start()'''

from multiprocessing import Queue, Process
import random
import time

def consumer(q,name):    # 消费者：通常渠道数据之后还要进行某些操作
    while True:
        food = q.get()
        if food:
            print(f"{name}吃了{food}")
        else:
            break
def producer(q, name, food):    # 生产者：通常在放数据之前要先通过某些代码来获取数据
    for i in range(10):
        foodi = '%s%s' % (food, i)
        print(f"{name}生产了{foodi}")
        time.sleep(random.random())
        q.put(foodi)

if __name__ == "__main__":
    q = Queue()
    c = Process(target=consumer, args=(q, 'aaa'))
    p1 = Process(target=producer, args=(q, 'zzz', 'banana'))
    p2 = Process(target=producer, args=(q, 'ccc', 'apple'))
    c.start()
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    q.put(None)