[oeasy]python0033_任务管理_jobs_切换任务_进程树结构_fg

简介: [oeasy]python0033_任务管理_jobs_切换任务_进程树结构_fg

 

查看进程

回忆上次内容

    • 上次先进程查询
      • ps -elf 查看所有进程信息
      • ps -lf 查看本终端相关进程信息
        • 杀死进程
          • kill -9 PID 给进程发送死亡信号
            • 运行多个 python3 show_time.py 的话
              • 各个进程独立
              • python3 show_time.py 大概 8+M
              • 各占内存
                • 这些进程之间是什么关系呢?🤔

                image.gif编辑

                具体查询

                  • zsh进程相关的 3 个进程
                    • zsh(当前的 shell 环境)
                      • zsh(shell本身)进程
                        • /usr/bin/python3 /home/shiyanlou/sleep.py
                          • 输出时间的python程序
                            • ps -lf
                              • 查询进程的ps进程

                                  image.gif编辑

                                    • 这进程之间有父子关系

                                    父子关系

                                      • pid 是指进程的 id
                                        • process id
                                          • ppid 是指 进程 id
                                            • parent process id
                                              • ppidpid 的爸爸

                                              image.gif编辑

                                                • pspython3 都是 zsh 的子进程
                                                • python3 这个进程占内存是 SZ
                                                  • 4860 个 Page
                                                  • 每个 page 大概 4K
                                                    • 总共 10+M

                                                        image.gif编辑

                                                          • python3 这个文件不是本身才 4.3M 么
                                                            • 都装进内存也就是 4.3M
                                                            • 都装进内存页没有 10+M 呀?

                                                              10+M 的原因

                                                                • 除了基础的部分(内建模块函数)之外
                                                                  • print()
                                                                  • ord()、chr()
                                                                  • int()、hex()、bin()
                                                                    • 还有新加载的部分
                                                                      • sleep.py
                                                                      • 还有 import 进来的 time 这个 module

                                                                        实际分配

                                                                        ps -o pid,ppid,sz,vsz,rss,cmd

                                                                          • SZ 是欲分配的内存用页(4K)来当单位
                                                                          • VSZ 是欲分配的内存用 K 来当单位

                                                                          image.gif编辑

                                                                            • RSS 非交换区的内存用 K 来当单位
                                                                            • 也就是说实际这个东西也就 8+M

                                                                            image.gif编辑

                                                                            后台多任务查询jobs

                                                                              • 还可以用jobs查看当前的任务

                                                                              image.gif编辑

                                                                                • jobs 可以看到后台的任务
                                                                                  • 我们可以切换任务到前台吗

                                                                                    将任务切换到前台

                                                                                    image.gif编辑

                                                                                      • fg 可以
                                                                                        • 将最后一个任务(3#job)
                                                                                        • 切换到前台
                                                                                          • 可以切2#job吗?

                                                                                          指定任务进行切换

                                                                                            • 我们可以用 fg 加参数的方式
                                                                                              • 把指定编号的进程恢复到前台
                                                                                              • 注意前面的 1193、1527、1542 分别是他们的 pid

                                                                                                image.gif编辑

                                                                                                  • 这就是前后台切换
                                                                                                    • 用 ctrl + z 把当前进程切换到后台
                                                                                                    • 用jobs查询当前shell的后台任务
                                                                                                    • 用ps可以查看进程
                                                                                                    • 用kill可以结束进程
                                                                                                    • 用 ctrl + c 结束当前前台的进程
                                                                                                      • jobs这个词怎么来的呢?

                                                                                                      jobs

                                                                                                        • 词源字典
                                                                                                          • 凯尔特语(gob)、(gop)
                                                                                                          • 原意就是口(the mouth)
                                                                                                          • 中古英语就变成(jobbe)
                                                                                                            • 一堆(lump)
                                                                                                            • 一口(mouthful)
                                                                                                              • 再演变而成一件工作

                                                                                                                image.gif编辑

                                                                                                                  • work
                                                                                                                    • 是长时期稳定的工作
                                                                                                                    • 全日制的工作
                                                                                                                      • jobs
                                                                                                                        • 是临时突发的工作
                                                                                                                        • 零工
                                                                                                                        • 偷窃也叫jobs
                                                                                                                          • 如果两个jobs的话
                                                                                                                            • 占用内存会变小吗?

                                                                                                                              两个进程

                                                                                                                                • 我们开两个 show_time.py
                                                                                                                                • PID 分别是 422、514

                                                                                                                                image.gif编辑

                                                                                                                                  • 然后观察到
                                                                                                                                    • 每个 python进程 实际分配差不多都是 9M(RSS)
                                                                                                                                    • 相互之间是独立的兄弟进程
                                                                                                                                    • 但是从逻辑上都属于zsh的子进程
                                                                                                                                      • 先运行的进程在非交换区的内存占用略高
                                                                                                                                          • 如果开多个xfce 进程情况又是如何呢?
                                                                                                                                          • 再打开几个xfce终端

                                                                                                                                          进程层次关系

                                                                                                                                            • ps -elf
                                                                                                                                              • 拉到最后
                                                                                                                                              • 找zsh和上级的xfce4

                                                                                                                                                image.gif编辑

                                                                                                                                                  • 祖父是xfce4-terminal
                                                                                                                                                    • 大伯是zsh(252)
                                                                                                                                                      • 家里三个兄弟
                                                                                                                                                        • 二伯是zsh(405)
                                                                                                                                                          • 家里也是三兄弟
                                                                                                                                                              • 就像一棵树
                                                                                                                                                                • 可以用树的形式观察吗?

                                                                                                                                                                  pstree

                                                                                                                                                                    • pstree -h 命令查看这棵树

                                                                                                                                                                    image.gif编辑

                                                                                                                                                                      • 可以看到清晰地父子兄弟关系

                                                                                                                                                                      总结

                                                                                                                                                                        • 进程前后台切换
                                                                                                                                                                          • ctrl + z 把当前进程切换到后台并暂停
                                                                                                                                                                          • jobs 查看所有作业
                                                                                                                                                                          • fg 可以把进程再切回前台
                                                                                                                                                                            • fg %1 可以把指定的进程切回前台
                                                                                                                                                                              • bg 可以让进程在后台运行
                                                                                                                                                                                • 进程查询
                                                                                                                                                                                  • ps -elf 查看所有进程信息
                                                                                                                                                                                  • ps -lf 查看本终端相关进程信息
                                                                                                                                                                                  • kill -9 PID 给进程发送死亡信号
                                                                                                                                                                                  • pstree -h 可以查看进程树
                                                                                                                                                                                    • 运行多个 python3 sleep.py 的话
                                                                                                                                                                                      • 各个进程独立
                                                                                                                                                                                      • python3 sleep.py 大概 7M
                                                                                                                                                                                      • 各占内存
                                                                                                                                                                                        • 这个切进程很好用
                                                                                                                                                                                          • 不过运行进程的时候总是满屏刷时间
                                                                                                                                                                                            相关文章
                                                                                                                                                                                            |
                                                                                                                                                                                            16天前
                                                                                                                                                                                            |
                                                                                                                                                                                            存储 对象存储 Python
                                                                                                                                                                                            Python|玩转 Asyncio 任务处理(1)
                                                                                                                                                                                            Python|玩转 Asyncio 任务处理(1)
                                                                                                                                                                                            21 5
                                                                                                                                                                                            |
                                                                                                                                                                                            5天前
                                                                                                                                                                                            |
                                                                                                                                                                                            监控 Unix 开发者
                                                                                                                                                                                            Python 3.9的多进程优化策略具体是如何实现的?
                                                                                                                                                                                            【7月更文挑战第2天】Python 3.9的多进程优化策略具体是如何实现的?
                                                                                                                                                                                            10 1
                                                                                                                                                                                            |
                                                                                                                                                                                            5天前
                                                                                                                                                                                            |
                                                                                                                                                                                            开发者 Python
                                                                                                                                                                                            Python 3.9的异步编程和多进程优化有哪些改进?
                                                                                                                                                                                            【7月更文挑战第2天】Python 3.9的异步编程和多进程优化有哪些改进?
                                                                                                                                                                                            9 1
                                                                                                                                                                                            |
                                                                                                                                                                                            25天前
                                                                                                                                                                                            |
                                                                                                                                                                                            Python
                                                                                                                                                                                            Python编程实战:如何将列表组装成一棵树结构
                                                                                                                                                                                            本文介绍了如何在Python中将列表转换为树结构。首先定义`TreeNode`类表示节点,包含值和子节点列表。然后,通过`list_to_tree`函数递归地将列表转为树。此外,还提供了添加和删除节点的方法。文章旨在帮助读者理解和操作树结构,以解决实际编程问题。
                                                                                                                                                                                            Python编程实战:如何将列表组装成一棵树结构
                                                                                                                                                                                            |
                                                                                                                                                                                            11天前
                                                                                                                                                                                            |
                                                                                                                                                                                            开发框架 并行计算 安全
                                                                                                                                                                                            Python的GIL限制了CPython在多核下的并行计算,但通过替代解释器(如Jython, IronPython, PyPy)和多进程、异步IO可规避
                                                                                                                                                                                            【6月更文挑战第26天】Python的GIL限制了CPython在多核下的并行计算,但通过替代解释器(如Jython, IronPython, PyPy)和多进程、异步IO可规避。Numba、Cython等工具编译优化代码,未来社区可能探索更高级的并发解决方案。尽管GIL仍存在,现有策略已能有效提升并发性能。
                                                                                                                                                                                            19 3
                                                                                                                                                                                            |
                                                                                                                                                                                            13天前
                                                                                                                                                                                            |
                                                                                                                                                                                            Python
                                                                                                                                                                                            Python多进程编程详细剖析
                                                                                                                                                                                            Python多进程编程详细剖析
                                                                                                                                                                                            16 3
                                                                                                                                                                                            |
                                                                                                                                                                                            17天前
                                                                                                                                                                                            |
                                                                                                                                                                                            安全 Java Python
                                                                                                                                                                                            GIL是Python解释器的锁,确保单个进程中字节码执行的串行化,以保护内存管理,但限制了多线程并行性。
                                                                                                                                                                                            【6月更文挑战第20天】GIL是Python解释器的锁,确保单个进程中字节码执行的串行化,以保护内存管理,但限制了多线程并行性。线程池通过预创建线程池来管理资源,减少线程创建销毁开销,提高效率。示例展示了如何使用Python实现一个简单的线程池,用于执行多个耗时任务。
                                                                                                                                                                                            21 6
                                                                                                                                                                                            |
                                                                                                                                                                                            13天前
                                                                                                                                                                                            |
                                                                                                                                                                                            算法 API 调度
                                                                                                                                                                                            |
                                                                                                                                                                                            18天前
                                                                                                                                                                                            |
                                                                                                                                                                                            Python Windows
                                                                                                                                                                                            在 Windows 平台下打包 Python 多进程代码为 exe 文件的问题及解决方案
                                                                                                                                                                                            在使用 Python 进行多进程编程时,在 Windows 平台下可能会出现将代码打包为 exe 文件后无法正常运行的问题。这个问题主要是由于在 Windows 下创建新的进程需要复制父进程的内存空间,而 Python 多进程机制需要先完成父进程的初始化阶段后才能启动子进程,所以在这个过程中可能会出现错误。此外,由于没有显式导入 Python 解释器,也会导致 Python 解释器无法正常工作。为了解决这个问题,我们可以使用函数。
                                                                                                                                                                                            21 5
                                                                                                                                                                                            |
                                                                                                                                                                                            21天前
                                                                                                                                                                                            |
                                                                                                                                                                                            运维 监控 API
                                                                                                                                                                                            自动化运维实践指南:Python脚本优化服务器管理任务
                                                                                                                                                                                            本文探讨了Python在自动化运维中的应用,介绍了使用Python脚本优化服务器管理的四个关键步骤:1) 安装必备库如paramiko、psutil和requests;2) 使用paramiko进行远程命令执行;3) 利用psutil监控系统资源;4) 结合requests自动化软件部署。这些示例展示了Python如何提升运维效率和系统稳定性。
                                                                                                                                                                                            36 8