操作系统的作用：

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 os22 import time23 from multiprocessing import Process24 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 os21 # from multiprocessing import Process22 #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 os42 # from multiprocessing import Process43 # class MyProcess(Process):44 #     def __init__(self,arg1,arg2):45 #         super().__init__()46 #         self.arg1 = arg147 #         self.arg2 = arg248 #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 = 10012     p = Process(target=func)13     p.start()14     p.join()15     print(os.getpid(),n) 16 17 # 没有 join()18 # 5984 10019 # pid：22804 020 21 # 有 join()22 # pid：17472 023 # 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 socket19 from multiprocessing import Process20 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 = 028     # while i < 5:29     #     print("我是socket server")30     #     time.sleep(5)31     #     i += 132 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"] -= 120         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()

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