进程是个什么玩意儿

1.进程是什么?

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

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

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

 1 from multiprocessing import Process
 2 import os
 3 
 4 
 5 def func(args1):
 6     print("hello world")
 7     print("func进程PID:%s,以及父进程PID:%s" % (os.getpid(), os.getppid()))
 8     print("我是主进程创建我的时候传递进来的参数:", args1)
 9     """
10     讲道理 主进程开辟了一个新空间 创建了一个新进程 这里面运行的是func函数 
11     那么 控制台是不应该输出的 因为子进程是在后台执行 但是编译器帮我们做了优化
12     所以子进程的内容也在控制台打印了
13     """
14 
15 
16 # 这个if是在Windows操作系统里面才有的
17 if __name__ == "__main__":
18     # 注册一个进程 这里面需要注意的是传递的参数是元组 只有一个参数要加逗号
19     p = Process(target=func, args=(1,))
20     p.start()
21     print("我是在前面异步执行")
22     p.join()  # 感知子进程p结束
23     print("=" * 10)
24     print("主进程ID是", os.getpid())
25 """
26 我是在前面异步执行
27 hello world
28 func进程PID:2144,以及父进程PID:1496
29 我是主进程创建我的时候传递进来的参数: 1
30 ==========
31 主进程ID是 1496
32 """
View Code

 3.用类方法创建进程

 1 from multiprocessing import Process
 2 import os
 3 
 4 
 5 class MyProcess(Process):
 6     def __init__(self, name, age):
 7         super().__init__()
 8         self.name_str = name
 9         self.age = age
10 
11     def run(self):
12         print(self.name)
13         print(self.pid)
14         print(self.name_str, self.age)
15 
16     # def start(self):
17     #     self.run()
18     # 传参数的继承类里面的init方法
19 
20 
21 if __name__ == "__main__":
22     # 对象实例化
23     p1 = MyProcess("张三", "年芳18")
24     p1.start()
25     p2 = MyProcess("李四", "二十有四")
26     p2.start()
27     p1.join()  # 感知主进程结束
28     p2.join()
29     print("主进程:", os.getpid())
30 """
31 MyProcess-1
32 5832
33 张三 年芳18
34 MyProcess-2
35 1468
36 李四 二十有四
37 主进程: 6220
38 """
View Code

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

 1 import json
 2 import time
 3 from multiprocessing import Process
 4 from multiprocessing import Lock
 5 
 6 
 7 def show(i):
 8     with  open("ticket", mode="r", encoding="utf-8") as f:
 9         s = json.load(f)
10         print("第%s人查询:还有%s张票" % (i, s["ticket"]))
11 
12 
13 def buy_ticket(num, lock):
14     lock.acquire()
15     time.sleep(0.1)
16     with open("ticket", mode="r", encoding="utf-8") as t:
17         dic = json.load(t)
18         # print(s)
19         if dic["ticket"] > 0:
20             dic["ticket"] -= 1
21             print("%s买到票了" % num)
22         else:
23             print("%s没买到票" % num)
24 
25     with open("ticket", "w", encoding="utf-8") as f:
26         json.dump(dic, f, ensure_ascii=False)
27         f.close()
28     lock.release()
29 
30 
31 if __name__ == "__main__":
32     # for i in range(10):
33     #     p = Process(target=show, args=(i,))
34     #     p.start()
35     lock = Lock()
36 
37     for i in range(10):
38         p = Process(target=buy_ticket, args=(i, lock))
39         p.start()
40 """
41 2买到票了
42 8买到票了
43 6买到票了
44 4买到票了
45 5买到票了
46 9没买到票
47 0没买到票
48 3没买到票
49 7没买到票
50 1没买到票
51 """
View Code

5.事件

 1 import time
 2 import random
 3 from multiprocessing import Event, Process
 4 
 5 
 6 def cars(i, e):
 7     if not e.is_set():
 8         print("%s在等待" % i)
 9         e.wait()
10     print("%s通过" % i)
11 
12 
13 def light(e):
14     while True:
15         if e.is_set():
16             e.clear()
17             print('33[31m红灯亮了33[0m')
18 
19 
20         else:
21             e.set()
22             print('33[32m绿灯亮了33[0m')
23         time.sleep(2)
24 
25 
26 if __name__ == "__main__":
27     e = Event()
28     p = Process(target=light, args=(e,))
29     p.start()
30     for i in range(20):
31         car = Process(target=cars, args=(i, e))
32         car.start()
33         time.sleep(random.randint(0,3))
View Code

6.队列

 1 from multiprocessing import Queue
 2 from multiprocessing import Process
 3 
 4 
 5 def produce(q):
 6     q.put("produce传过来的helloworld")
 7 
 8 
 9 def consumer(q):
10     print("我是consumer 正在等待:", q.get())
11 
12 
13 if __name__ == "__main__":
14     q = Queue()
15     p = Process(target=produce, args=(q,))
16     p.start()
17     c = Process(target=consumer, args=(q,))
18     c.start()
19 
20 """
21 我是consumer 正在等待: produce传过来的helloworld
22 """
View Code

7.生产者消费者模型(Queue版本)

 1 from multiprocessing import Process
 2 from multiprocessing import Queue
 3 import time, random
 4 
 5 
 6 def producer(name, food, q):
 7     for i in range(10):
 8         time.sleep(random.randint(0, 3))
 9         f = "%s生产第%s个%s" % (name, i, food)
10         print(f)
11         q.put(f)
12 
13 
14 def consumer(name, q):
15     while True:
16         time.sleep(random.randint(0, 3))
17         if q.get() == None:
18             break
19         print("%s消费了%s" % (name, q.get()))
20 
21 
22 if __name__ == "__main__":
23     q = Queue(20)
24     p1 = Process(target=producer, args=("p1", "包子", q))
25     p2 = Process(target=producer, args=("p2", "饺子", q))
26     c1 = Process(target=consumer, args=("c1", q))
27     c2 = Process(target=consumer, args=("c2", q))
28     c1.start()
29     p2.start()
30     p1.start()
31     c2.start()
32     p1.join()
33     p2.join()
34     q.put(None)
35     q.put(None)
View Code

8.生产者消费者模型(joinableQueue版本)

 1 from multiprocessing import Process
 2 from multiprocessing import JoinableQueue
 3 import time
 4 import random
 5 
 6 
 7 def producer(name, food, q):
 8     for i in range(3):
 9         time.sleep(random.randint(0, 3))
10         f = "%s生产第%s个%s" % (name, i, food)
11         print(f)
12         q.put(f)
13     q.join()  # 等待标记全部完成
14 
15 
16 def consumer(name, q):
17     while True:
18         time.sleep(random.randint(0, 3))
19         print("%s消费了%s" % (name, q.get()))
20         q.task_done()  # 这是一个标记
21 
22 
23 if __name__ == "__main__":
24     q = JoinableQueue(10)
25     p1 = Process(target=producer, args=("p1", "包子", q))
26     p2 = Process(target=producer, args=("p2", "饺子", q))
27     c1 = Process(target=consumer, args=("c1", q))
28     c2 = Process(target=consumer, args=("c2", q))
29     c1.daemon = True
30     c2.daemon = True  # 设置为守护进程 等待主进程的代码执行完毕之后在执行
31     c1.start()
32     c2.start()
33 
34     p2.start()
35     p1.start()
36 
37     p1.join()
38     p2.join()
39 """
40 生产者这一端:
41     1.每次获取一个数据
42     2.处理一个数据
43     3.发送一个记号:标志一个数据被处理成功
44 在生产者这一端:
45     1.每一次生产一个数据
46     2.且每一次生产的数据都放在队列里面
47     3.在队列里面刻上一个记号
48     4.当生产者全部生产完毕之后
49         join信号:已经停止生产数据了
50                  且要等待之前被刻上记号都被消耗完
51                  当数据都被处理完时,join信号阻塞结束
52     
53     
54 consumer中把所有的任务消耗完
55 producer端的join感知到,停止阻塞
56 所有的producer进程结束
57 主进程的p.join结束
58 主进程里面代码结束
59 守护进程(消费者进程)结束
60 """
View Code
原文地址:https://www.cnblogs.com/d9e84208/p/10609525.html