标签：win os.walk sock 定义 业务 提高效率 multi 顺序 处理机
操作系统的作用：
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()
# 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。
标签：win os.walk sock 定义 业务 提高效率 multi 顺序 处理机
原文地址：https://www.cnblogs.com/pioneerLee/p/10305910.html
