进程是个什么玩意儿

1.进程是什么？

　　进程是加载内存里面正在运行的程序，一定要是在运行的哈，没事在纸上写了一段代码，那个只是程序，不是进程。

　　其他的说法自己去翻操作系统

2.用函数方法创建进程  口水话见代码

from multiprocessing import Process
import os


def func(args1):
    print("hello world")
    print("func进程PID:%s，以及父进程PID:%s" % (os.getpid(), os.getppid()))
    print("我是主进程创建我的时候传递进来的参数:", args1)
    """
    讲道理 主进程开辟了一个新空间 创建了一个新进程 这里面运行的是func函数 
    那么 控制台是不应该输出的 因为子进程是在后台执行 但是编译器帮我们做了优化
    所以子进程的内容也在控制台打印了
    """


# 这个if是在Windows操作系统里面才有的
if __name__ == "__main__":
    # 注册一个进程 这里面需要注意的是传递的参数是元组 只有一个参数要加逗号
    p = Process(target=func, args=(1,))
    p.start()
    print("我是在前面异步执行")
    p.join()  # 感知子进程p结束
    print("=" * 10)
    print("主进程ID是", os.getpid())
"""
我是在前面异步执行
hello world
func进程PID:2144，以及父进程PID:1496
我是主进程创建我的时候传递进来的参数: 1
==========
主进程ID是 1496
"""

 3.用类方法创建进程

from multiprocessing import Process
import os


class MyProcess(Process):
    def __init__(self, name, age):
        super().__init__()
        self.name_str = name
        self.age = age

    def run(self):
        print(self.name)
        print(self.pid)
        print(self.name_str, self.age)

    # def start(self):
    #     self.run()
    # 传参数的继承类里面的init方法


if __name__ == "__main__":
    # 对象实例化
    p1 = MyProcess("张三", "年芳18")
    p1.start()
    p2 = MyProcess("李四", "二十有四")
    p2.start()
    p1.join()  # 感知主进程结束
    p2.join()
    print("主进程:", os.getpid())
"""
MyProcess-1
5832
张三 年芳18
MyProcess-2
1468
李四 二十有四
主进程: 6220
"""

4.锁机制 这里面需要在py文件同目录新建文件夹 放入内容“{"ticket": 5}”

import json
import time
from multiprocessing import Process
from multiprocessing import Lock


def show(i):
    with  open("ticket", mode="r", encoding="utf-8") as f:
        s = json.load(f)
        print("第%s人查询:还有%s张票" % (i, s["ticket"]))


def buy_ticket(num, lock):
    lock.acquire()
    time.sleep(0.1)
    with open("ticket", mode="r", encoding="utf-8") as t:
        dic = json.load(t)
        # print(s)
        if dic["ticket"] > 0:
            dic["ticket"] -= 1
            print("%s买到票了" % num)
        else:
            print("%s没买到票" % num)

    with open("ticket", "w", encoding="utf-8") as f:
        json.dump(dic, f, ensure_ascii=False)
        f.close()
    lock.release()


if __name__ == "__main__":
    # for i in range(10):
    #     p = Process(target=show, args=(i,))
    #     p.start()
    lock = Lock()

    for i in range(10):
        p = Process(target=buy_ticket, args=(i, lock))
        p.start()
"""
2买到票了
8买到票了
6买到票了
4买到票了
5买到票了
9没买到票
0没买到票
3没买到票
7没买到票
1没买到票
"""

5.事件

import time
import random
from multiprocessing import Event, Process


def cars(i, e):
    if not e.is_set():
        print("%s在等待" % i)
        e.wait()
    print("%s通过" % i)


def light(e):
    while True:
        if e.is_set():
            e.clear()
            print('\033[31m红灯亮了\033[0m')


        else:
            e.set()
            print('\033[32m绿灯亮了\033[0m')
        time.sleep(2)


if __name__ == "__main__":
    e = Event()
    p = Process(target=light, args=(e,))
    p.start()
    for i in range(20):
        car = Process(target=cars, args=(i, e))
        car.start()
        time.sleep(random.randint(0,3))

6.队列

from multiprocessing import Queue
from multiprocessing import Process


def produce(q):
    q.put("produce传过来的helloworld")


def consumer(q):
    print("我是consumer 正在等待:", q.get())


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

"""
我是consumer 正在等待: produce传过来的helloworld
"""

7.生产者消费者模型（Queue版本）

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


def producer(name, food, q):
    for i in range(10):
        time.sleep(random.randint(0, 3))
        f = "%s生产第%s个%s" % (name, i, food)
        print(f)
        q.put(f)


def consumer(name, q):
    while True:
        time.sleep(random.randint(0, 3))
        if q.get() == None:
            break
        print("%s消费了%s" % (name, q.get()))


if __name__ == "__main__":
    q = Queue(20)
    p1 = Process(target=producer, args=("p1", "包子", q))
    p2 = Process(target=producer, args=("p2", "饺子", q))
    c1 = Process(target=consumer, args=("c1", q))
    c2 = Process(target=consumer, args=("c2", q))
    c1.start()
    p2.start()
    p1.start()
    c2.start()
    p1.join()
    p2.join()
    q.put(None)
    q.put(None)

8.生产者消费者模型（joinableQueue版本）

from multiprocessing import Process
from multiprocessing import JoinableQueue
import time
import random


def producer(name, food, q):
    for i in range(3):
        time.sleep(random.randint(0, 3))
        f = "%s生产第%s个%s" % (name, i, food)
        print(f)
        q.put(f)
    q.join()  # 等待标记全部完成


def consumer(name, q):
    while True:
        time.sleep(random.randint(0, 3))
        print("%s消费了%s" % (name, q.get()))
        q.task_done()  # 这是一个标记


if __name__ == "__main__":
    q = JoinableQueue(10)
    p1 = Process(target=producer, args=("p1", "包子", q))
    p2 = Process(target=producer, args=("p2", "饺子", q))
    c1 = Process(target=consumer, args=("c1", q))
    c2 = Process(target=consumer, args=("c2", q))
    c1.daemon = True
    c2.daemon = True  # 设置为守护进程 等待主进程的代码执行完毕之后在执行
    c1.start()
    c2.start()

    p2.start()
    p1.start()

    p1.join()
    p2.join()
"""
生产者这一端:
    1.每次获取一个数据
    2.处理一个数据
    3.发送一个记号：标志一个数据被处理成功
在生产者这一端:
    1.每一次生产一个数据
    2.且每一次生产的数据都放在队列里面
    3.在队列里面刻上一个记号
    4.当生产者全部生产完毕之后
        join信号:已经停止生产数据了
                 且要等待之前被刻上记号都被消耗完
                 当数据都被处理完时，join信号阻塞结束
    
    
consumer中把所有的任务消耗完
producer端的join感知到，停止阻塞
所有的producer进程结束
主进程的p.join结束
主进程里面代码结束
守护进程(消费者进程)结束
"""