进程基础复习

Posted 2021-02-05 pioneerlee

操作系统的作用：

1，隐藏丑陋复杂的硬件接口，提供良好的抽象接口

2，管理、调度进程，并且将多个进程对硬件的竞争变得有序。

 

程序 是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。
进程 是程序在处理机上的一次执行过程，它是一个动态的概念。
程序可以作为一种软件资料长期存在，而进程是有一定生命期的。
程序是永久的，进程是暂时的。
注意：同一个程序执行两次，就会在操作系统中出现两个进程，所以
我们可以同时运行一个软件，分别做不同的事情也不会混乱。

 

进程调度=====
先来先服务调度算法
短作业优先调度算法
时间片轮转法
多级反馈队列：分成好几个层级  最高一级为最高优先级，他执行一个时间片，执行
完一个时间片 如果没执行完，就给他降一个优先级，接着在执行一个时间片。
这样短作业会在第一层就执行完，长作业本来就不着急 所以就让他慢慢执行就行。

进程的并行与并发
并行：并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑；（并行必须是多核的）

并发：并发是指资源有限的情况的下，两者交替轮流使用资源，比如一段路（单核CPU资源）同
时只能过一个人，A走一段后，让给B，B用完继续给A，交替使用，目的是提高效率。

同步 异步 阻塞 非阻塞====

进程的三状态图：创建----》就绪-----》运行-----（三角）遇到阻塞---》回到就绪-----》再走运行----》退出


同步：（同一时间，只能做一件事情）所谓同步  就是一个任务的完成需要依赖
另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，
这是一种可靠地任务序列。要么成功都成功，要么失败都失败，两个任务的状态可以保持一致。
有一定的先后顺序

 
异步：（同一时间，能做多件事情） 所谓异步，就是不需要等待被依赖的任务
完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要
自己完成了整个任务就算完成了。至于被依赖的任务最终是否正真完成，依赖
他的任务无法确定，所以他是不可靠的任务序列。

 

例子：比如我去银行办理业务，可能会有两种方式：
同步阻塞  第一种：一直排队等候，中间你不能做其它的事情，这就是同步  
异步阻塞  第二种：可以选取一张小纸条上面有号码，我不用一直在这里排队等候，可以去做其他事情，等到我的时候，有人过来通知我。

 

 1 import os
 2 import time
 3 from multiprocessing import Process
 4 def func(args,args2):
 5     print(args,args2)
 6     time.sleep(1)
 7     print("子进程：",os.getpid())
 8     print("子进程的父进程：",os.getppid())
 9     print(12345)
10 
11 if __name__== "__main__":  # 在Windows上需要这句话，Linux与mac不需要这句话
12     p = Process(target=func,args=(54321,"参数"))  # 把func注册到这个进程里 
13 # （这里是主进程）
14                                 # 传一个参数 必须得有逗号,args 必须是元祖
15     # p是一个进程对象，还没有启动进程
16     p.start()  # 这里是一个子进程
17     print("*"*10)
18     print("父进程：",os.getpid(5))  # 查看当前的进程号
19     print("父进程的父进程：",os.getppid())  # 查看当前进程的父进程

# 进程的生命周期
    # 主进程
    # 子进程
    # 开启了子进程的主进程：
      # 主进程自己的代码如果长，等待自己的代码执行结束，
      # 子进程的执行时间长，主进程会在主进程代码执行完毕之后等待子进程执行完毕之后 主进程才结束。

 

 1 # 多进程当中的方法
 2 
 3 import time
 4 from multiprocessing import Process
 5 
 6 def func(arg1,arg2):
 7     print("*"*arg1)
 8     time.sleep(5)
 9     print("*"*arg2)
10 
11 if __name__ == "__main__":
12     p = Process(target=func,args=(10,20))
13     p.start()
14     print("login")
15     p.join()  # 将异步的程序变成了同步
16     print("=====:运行完了")

 

 1 # 开启多个子进程
 2 # import time
 3 # from multiprocessing import Process
 4 #
 5 # def func(arg1,arg2):
 6 #     print("*"*arg1)
 7 #     time.sleep(5)
 8 #     print("*"*arg2)
 9 #
10 # if __name__ == "__main__":
11 #     p_list = []
12 #     for i in range(10):
13 #         p = Process(target=func,args=(10*i,20*i))
14 #         p_list.append(p)
15 #         p.start()
16 #         for p in p_list:
17 #             p.join()
18 #         print("运行完了")
19 
20 
21 import os
22 import time
23 from multiprocessing import Process
24 def func(filename,content):
25     with open(filename,"w") as f:
26         f.write(content*"*")
27 
28 if __name__ == "__main__":
29     p_list = []
30     for i in range(10):
31         p = Process(target=func,args=("info%s"%i,i))
32         p_list.append(p)
33         p.start()
34     for p in p_list:p.join()  # 这句话的意思，是等待所有进程执行完，
35                                           # 在执行下面的语句。
36     print(os.walk(r"E:Python daima3.开启多个子进程.py"))  # 查看当前
37                                                              #文件夹里的所有文件

 

 1 # 开启多进程的第二种方式
 2 
 3 # import os
 4 # from multiprocessing import Process
 5 #
 6 # class MyProcess(Process):  #定义一个类 并继承Process
 7 #     def run(self):
 8 #         print(self.pid)   # 进程号
 9 #         print(self.name)  # 当前进程的名字
10 #         print(os.getpid())  # 查看进程号  pid 与它一样
11 #
12 # if __name__ == "__main__":
13 #     print("主：",os.getpid())
14 #     p1 = MyProcess()
15 #     p1.start()
16 #     p2 = MyProcess()
17 #     p2.start()
18 
19 
20 # import os
21 # from multiprocessing import Process
22 #
23 # class MyProcess(Process):
24 #     def run(self):
25 #         print(self.pid)
26 #         print(self.name)
27 #
28 # if __name__ == "__main__":
29 #     print("主：",os.getpid())
30 #     p1 = MyProcess()
31 #     p1.start()  # 在这调用start方法，就会在start内部创建一个进程，
32 #                  # 并会把run方法里的内容放到进程中去执行。
33 #     p2 = MyProcess()
34 #     p2.start()
35 # 自定义类（MyProcess） 继承Process类
36 # 必须实现一个run方法，run方法中是在子进程中执行的代码
37 
38 
39 
40 # 如何传参数
41 # import os
42 # from multiprocessing import Process
43 # class MyProcess(Process):
44 #     def __init__(self,arg1,arg2):
45 #         super().__init__()
46 #         self.arg1 = arg1
47 #         self.arg2 = arg2
48 #
49 #     def run(self):
50 #         print(self.pid)
51 #         print(self.name)
52 #         print(self.arg1)
53 #         print(self.arg2)
54 #
55 # if __name__ == "__main__":
56 #     p1 = MyProcess(1,2)
57 #     p1.start()
58 #     p2 = MyProcess(3,4)
59 #     p2.start()
60 
61 # 如果需要传参数，你就重写一个__init__方法，并在括号里写上需要传的参数，
62 #  然后把参数帮给self，不要忘了父类的__init__的方法。

 

 1 # 进程之间的数据是完全隔离的
 2 import os
 3 from multiprocessing import Process
 4 
 5 def func():
 6     global n
 7     n = 0
 8     print("pid：%s"%os.getpid(),n)
 9 
10 if __name__ == "__main__":
11     n = 100
12     p = Process(target=func)
13     p.start()
14     p.join()
15     print(os.getpid(),n) 
16 
17 # 没有 join()
18 # 5984 100
19 # pid：22804 0
20 
21 # 有 join()
22 # pid：17472 0
23 # 23148 100

 

 

 1 # 使用多进程实现socket服务端的并发效果
 2 
 3 # client端
 4 import socket
 5 
 6 sk = socket.socket()
 7 sk.connect(("127.0.0.1",8080))
 8 
 9 msg = sk.recv(1024).decode("utf-8")
10 print(msg)
11 msg2 = input(">>>").encode("utf-8")
12 sk.send(msg2)
13 
14 sk.close()
15 
16 # server端
17 
18 import socket
19 from multiprocessing import Process
20 def serve(conn):
21     ret = "你好".encode("utf-8")
22     conn.send(ret)
23     msg = conn.recv(1024).decode("utf-8")
24     print(msg)
25     conn.close()
26 
27 if __name__ == "__main__":
28     sk = socket.socket()
29     sk.bind(("127.0.0.1",8080))
30     sk.listen()
31     while True:
32         conn,addr = sk.accept()
33         p = Process(target=serve,args=(conn,))
34         p.start()
35     sk.close()
36 
37 # 多进程的方式实现并发了
38 # 可以开启多个client端

 

 1 # 守护进程
 2 
 3 import time
 4 from multiprocessing import Process
 5 
 6 def func():
 7     while True:
 8         time.sleep(0.2)
 9         print("我还活着")
10 
11 def func2():
12     print("in func2 start")
13     time.sleep(8)
14     print("in func2 finished")
15 
16 if __name__ == "__main__":
17     p = Process(target=func)
18     p.daemon = True  # 设置子p进程为守护进程
19     p.start()
20     p2 = Process(target=func2)
21     p2.start()
22     p2.terminate()  # 结束一个子进程
23     print(p2.is_alive())
24     time.sleep(1)
25     print(p2.is_alive())
26     print(p2.name)
27     # i = 0
28     # while i < 5:
29     #     print("我是socket server")
30     #     time.sleep(5)
31     #     i += 1
32 
33 # 守护进程 会 随着 主进程的代码执行完毕 而 结束
34 # 在主进程内结束一个子进程 p.terminate()
35    # 结束一个进程不是在执行方法之后立即生效，需要一个操作系统响应的过程
36 # 检验一个进程是否活着的状态 p.is_alive()
37 # p.name p.pid  进程名字 与进程号

 

 1 # 锁 
 2 # 火车票
 3 import json
 4 import time
 5 from multiprocessing import Process
 6 from multiprocessing import Lock
 7 
 8 def show(i):
 9     with open("ticket") as f:
10         dic = json.load(f)
11     print("余票：%s"%dic["ticket"])
12 
13 def buy_ticket(i,lock):
14     lock.acquire()  # 拿钥匙进门
15     with open("ticket") as f:
16         dic = json.load(f)
17         time.sleep(0.1)
18     if dic["ticket"] > 0:
19         dic["ticket"] -= 1
20         print("33[32m%s买到票了33[0m"%i)
21     else:
22         print("33[31m%s没有买到票33[0m"%i)
23     time.sleep(0.1)
24     with open("ticket", "w") as f:
25         json.dump(dic, f)
26     lock.release()  # 还钥匙
27 
28 if __name__ == "__main__":
29     for i in range(10):
30         p = Process(target=show,args=(i,))
31         p.start()
32     lock = Lock()
33     for i in range(10):
34         p = Process(target=buy_ticket,args=(i,lock))
35         p.start()

 # 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。