进程基础复习01

操作系统的作用:

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 daima\3.开启多个子进程.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("\033[32m%s买到票了\033[0m"%i)
21     else:
22         print("\033[31m%s没有买到票\033[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()

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

posted @ 2019-01-22 20:29  牧羊世界  阅读(137)  评论(0编辑  收藏  举报