IT评测·应用市场-qidao123.com

标题: 进程 [打印本页]
作者: 泉缘泉    时间: 2022-9-16 17:19
标题: 进程
1 什么是进程

进程是系统进行资源分配和调度的基本单位，进程表示程序正在执行的过程，是‘活的’，而程序就是一推躺在硬盘上的代码，是‘死的’。
2 进程的调度

1.先来先服务调度算法：对长作业有利，对短作业无利
2.短作业优先调度算法：对短作业有利，对长作业无利
3.时间片轮转法+多级反馈队列
该方法是指，将时间片切成n份，每一份表示一个时间片，这些时间片有一个优先级顺序，最上面的优先执行，一个长任务第一个时间片没有完成会被放到第二个，如果第一个时间片有来任务会优先等第一个执行完在执行第二个。
3 进程的三状态图


4. 如何创建进程

4.1 进程创建的第一种方式（掌握）
  1. from multiprocessing import Process  # 导入进程模块
  2. import time
  4. # 子进程函数
  5. def func(name):
  6.     print('支线%s'% name)
  7.     time.sleep(3)
  8.     print('over%s'% name)
  10. # windows下创建进程，一定要在main下面创建
  11. # 因为windows创建进程类似于模块导入的方式，会从上往下依次执行，如果放在main外面，会一直创建进程下去
  12. # linux系统中只是将代码拷贝一份，因此不需要在main下面创建
  13. # main表示当该文件是执行文件时才会被运行，该文件是导入的形式时不会被运行
  14. if __name__ == '__main__':
  15.     # 1.创建进程对象
  16.     # 参数1：需要创建进程的目标函数；
  17.     # 参数2：需要给函数传的参数是一个元组形式，当需要传的参数是一个时，注意加一个,
  18.     p = Process(target=func,args=('yun',))
  19.     # 2.开启进程,告诉操作系统创建进程，操作系统会去申请一个内存空间，把子进程丢进去执行
  20.     p.start()
  21.     # 3.下面是主进程的执行
  22.     print('主')
复制代码
4.2 创建进程的第二种方式
  1. from multiprocessing import Process
  2. import time
  4. # 1.创建一个类，该类继承Process类
  5. class MyProcess(Process):
  6.     # 2.类中子进程的函数名必须是run
  7.     def run(self):
  8.         print('hello')
  9.         time.sleep(1)
  10.         print('gun')
  12. if __name__ == '__main__':
  13.     # 3.产生类的对象
  14.     p = MyProcess()
  15.     # 4.开启进程
  16.     p.start()
  17.     print('主')
复制代码
总结：
1.创建进程实际上就是在内存中申请了一块内存空间，将代码丢进去运行
2.一个进程产生一个内存空间，多个进程产生多个内存空间
3.进程之间默认是无法进行数据交互的，如果需要交互需要借助第三方模块，在子进程修改全局变量，全局变量不会改变
4.3 进程中join方法

join方法是用来让主进程代码等待调用join的子进程代码运行结束之后，在运行主进程！
  1.     p1.join()
  2.     p2.join()
  3.     p3.join()
  4.     print（'主'）
  5.     如果p2和p3不调用join方法，主进程就不会等待其运行结束后再运行！！！
复制代码
4.4 进程对象和其他方法

一台计算机上面运行着很多进程，那么计算机是如何区分并管理着这些进程，计算机会给这些进程各自分配一个pid
在windows终端，可以通过tasklist命令查看所有的进程pid
tasklist |findstr PID 查看具体进程的命令
在mac电脑，可以通过ps aux查看
ps aux|grep PID 查看具有进程的命令
进程的其他方法：
  1. from multiprocessing import Process,current_process
  2. import time
  3. import os
  5. def func():
  6.     # current_process().pid 获取当前进程的进程id
  7.     print('%s 正在运行'% current_process().pid)
  8.     time.sleep(2)
  10. if __name__ == '__main__':
  11.     p = Process(target=func)
  12.     p.start()
  13.     # os.getpid()也是获取当前进程id的方法
  14.     p.terminate() # 杀死当前进程，系统帮您杀死该进程，需要一定的时间，所有下面的is_alive可能为true
  15.     print(p.is_alive()) # 判断当前进程是否存活
  16.     print('主',os.getpid())
  17.     # os.getppid()是获取当前父id的方法
  18.     print('主主',os.getppid())
复制代码
4.5 僵尸进程与孤儿进程

僵尸进程：
当子进程死了，子进程并不会立即占用的进程id号，因为需要让父进程查看到子进程的id、运行时间等信息，所有进程会步入僵尸进程
回收子进程的id号：1，负进程调用join（）方法 2.父进程等待子进程运行完毕
孤儿进程：
子进程存活，父进程意外死亡。
操作系统会帮你自动回收子进程的资源
4.6 守护进程

"你死我也不独活"  p.daemon = True 方法设置守护进程
  1. from multiprocessing import Process,current_process
  2. import time
  4. def func():
  5.     print('奴隶活着')
  6.     time.sleep(2)
  7.     print('奴隶死去')
  9. if __name__ == '__main__':
  10.     p = Process(target=func)
  11.     p.daemon = True # 将p这个子进程设置成守护进程，这一句话一定要放在start前面，否则保错
  12.     p.start()
  13.     print('主人死了')
复制代码
4.7 进程中的互斥锁

多个进程操作同一个数据的时候，很可能会出现数据错乱的问题
针对上述问题，解决方案就是加锁处理：将并发变成串行，牺牲效率保证数据的安全准确
  1. # 1.导入锁模块
  2. from multiprocessing import Process LOCK
  4. # 2.在主进程中生成一把锁，让所有子进程去抢这把锁,mutex 需要传入对应函数的参数里面
  5. mutex = LOCK()
  7. # 3.在需要加锁的功能上面
  8. mutex.acquire()
  10. # 4.在功能执行完的下面，解锁
  11. mutex.release()
  13. 总结：
  14. 1.锁不要轻易使用，容易造成锁死的现象
  15. 2.锁只在需要争抢数据的时候使用，保证数据的安全
复制代码
4.8 进程间的通信

进程之间是无法相互通信的，因此需要采用第三方模块队列queue。
注意：队列中的数据是先进先出的。
  1. # 导入队列模块
  2. import queue
  3. # 也可以用下面这种方式之间导入到队列类
  4. from multiprocessing import Queue
  6. # 1.生成一个队列对象
  7. q = queue.Queue(3) # 括号内可以传数字，表示队列可以最大存放的数据量，不传有一个很大的默认值
  8. # 2.给队列存数据
  9. q.put(111)
  10. print(q.full()) # 判断当前队列是否存满
  11. q.put(222)
  12. print(q.empty()) # 判断当前队列是否为空
  13. q.put(333)
  14. print(q.full())
  15. # q.put(444) # 当给队列存的数据个数超过队列的最大存放数，队列会进入阻塞状态等待位置
  17. # 3.从队列中取值
  18. v1 = q.get()
  19. v2 = q.get()
  20. v3 = q.get()
  21. # v4  = q.get()  当队列中没有数据的时候，在次取值会使得队列进入阻塞
  22. v5 = q.get_nowait() # 当队列中没有数据可取的时候，就报错
  23. v6 = q.get(timeout=3) # 没有数据原地等待3秒，然后报错
  24. print(v1,v2,v3)
  26. # 总结：
  27. '''
  28. q.full()
  29. q.empty()
  30. q.get_nowait()
  31. 这三个方法在多进程下是不精确的
  32. '''
复制代码
IPC机制：
1.子进程和主进程之间的通信
2.子进程和子进程之间的通信
  1. from multiprocessing import Queue,Process
  3. def cosumer1(q):
  4.     # 在子进程中存数据
  5.     q.put('我是队列存的信息')
  6.     print('子进程1')
  8. def cosumer2(q):
  9.     # 在子进程中取数据
  10.     print(q.get())
  13. if __name__ == '__main__':
  14.     q = Queue()
  15.     p = Process(target=cosumer1,args=(q,))
  16.     p1 = Process(target=cosumer2,args=(q,))
  17.     p.start()
  18.     p1.start()
  19.     # 在主进程取出数据
  20.     # print(q.get())
复制代码
5. 进程的综合应用--生产者消费者模型
  1. from multiprocessing import Queue,Process,JoinableQueue
  2. import time
  3. import random
  5. # 生产者子进程
  6. def producer(name,food,q):
  7.     for i in range(5):
  8.         print('%s生产了%s%s'%(name,food,i))
  9.         time.sleep(random.randint(1,3))
  10.         q.put(food)
  12. def consumer(name,q):
  13.     # 消费者一直在吃，进入循环
  14.     while True:
  15.         food = q.get() # 当队列中没有东西的时候，该子进程会被卡住，进入阻塞状态
  16.         print('%s吃了%s'%(name,food))
  17.         q.task_done() # 该方法属于JoinableQueue，作用是告诉队列你已经从队列中取出一个数据并且处理完毕了
  19. if __name__ == '__main__':
  20.     # 将q = Queue()改成下面的方法创建队列
  21.     q = JoinableQueue()
  22.     # 两个生产者，分别生产的东西放进队列中
  23.     p1 = Process(target=producer,args=('zhang','包子',q))
  24.     p2 = Process(target=producer, args=('yang', '粥', q))
  25.     # 消费者从队列中取出东西吃掉
  26.     c1 = Process(target=consumer,args=('www',q))
  27.     p1.daemon = True  # 守护主进程，主进程结束杀死子进程
  28.     p2.daemon = True
  29.     c1.daemon = True
  30.     p1.start()
  31.     p2.start()
  32.     c1.start()
  33.     p1.join()
  34.     p2.join() # 等待生产者生产完毕在执行下面的代码
  35.     q.join()  # 等待队列中所有的数据被取完之后再执行下述代码
  37.     # JoinableQueue类
  38.     """
  39.     该类是在queue类上的基础上添加了一个计数器，每当往队列中存放一个数据时，计数器会加1；
  40.     当你调用task_done时，计数器减1
  41.     q.join()  等待计数器为0的时候在执行该方法下面的代码
  42.     """
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4