os模块篇（二十一）

os.sched_get_priority_min(policy)

os.sched_get_priority_min(policy) 是 Python 的 os 模块中的一个函数，用于获取指定调度策略的最低优先级值。在 Unix-like 系统中，进程调度策略和优先级允许你更细致地控制进程的执行顺序。

参数 policy 是一个整数，表示调度策略。在 Linux 上，常见的调度策略包括：

• os.SCHED_FIFO：先进先出（FIFO）调度策略。
• os.SCHED_RR：轮转（Round Robin）调度策略。
• os.SCHED_OTHER：默认调度策略，通常是时间片轮转。

os.sched_get_priority_min(policy) 返回给定调度策略下的最低优先级值。这个值通常是一个整数，代表了该策略下可以设置的最低优先级。

下面是一个使用 os.sched_get_priority_min() 的示例：

import os

# 获取 FIFO 调度策略下的最低优先级
min_priority_fifo = os.sched_get_priority_min(os.SCHED_FIFO)
print(f"FIFO min priority: {min_priority_fifo}")

# 获取 Round Robin 调度策略下的最低优先级
min_priority_rr = os.sched_get_priority_min(os.SCHED_RR)
print(f"Round Robin min priority: {min_priority_rr}")

# 尝试获取一个不存在的调度策略下的最低优先级将会引发错误
try:
    invalid_policy = 999
    min_priority_invalid = os.sched_get_priority_min(invalid_policy)
except OSError as e:
    print(f"Error: {e}")

需要注意的是，不是所有的系统都支持所有的调度策略和优先级设置。在调用 os.sched_get_priority_min() 之前，你应该检查你的系统是否支持指定的调度策略。

此外，更改进程的调度策略和优先级通常需要相应的权限，通常是 root 用户或具有 CAP_SYS_NICE 能力的用户才能执行这些操作。在 Python 中更改这些设置通常需要使用 os.setpriority() 或 os.sched_setscheduler() 函数。

os.sched_get_priority_max(policy)

os.sched_get_priority_max(policy) 是 Python 的 os 模块中的一个函数，用于获取指定调度策略的最高优先级值。这个函数允许你查询在 Unix-like 系统中，对于给定的调度策略，可以设置的最高优先级是多少。

参数 policy 是一个整数，表示调度策略，如 os.SCHED_FIFO、os.SCHED_RR 等。

os.sched_get_priority_max(policy) 返回给定调度策略下的最高优先级值。这个值通常是一个整数，代表了该策略下可以设置的最高优先级。

下面是一个使用 os.sched_get_priority_max() 的示例：

import os

# 获取 FIFO 调度策略下的最高优先级
max_priority_fifo = os.sched_get_priority_max(os.SCHED_FIFO)
print(f"FIFO max priority: {max_priority_fifo}")

# 获取 Round Robin 调度策略下的最高优先级
max_priority_rr = os.sched_get_priority_max(os.SCHED_RR)
print(f"Round Robin max priority: {max_priority_rr}")

# 尝试获取一个不存在的调度策略下的最高优先级将会引发错误
try:
    invalid_policy = 999
    max_priority_invalid = os.sched_get_priority_max(invalid_policy)
except OSError as e:
    print(f"Error: {e}")

请注意，不是所有的系统都支持所有的调度策略和优先级设置。在调用 os.sched_get_priority_max() 之前，你应该检查你的系统是否支持指定的调度策略。

此外，更改进程的调度策略和优先级通常需要相应的权限，通常是 root 用户或具有 CAP_SYS_NICE 能力的用户才能执行这些操作。在 Python 中更改这些设置通常需要使用 os.setpriority() 或 os.sched_setscheduler() 函数。

os.sched_setscheduler(pid, policy, param, /)

os.sched_setscheduler(pid, policy, param) 是 Python os 模块中的一个函数，用于设置指定进程的调度策略和参数。该函数允许你更改进程的调度策略以及与其关联的参数，从而更细致地控制进程在操作系统中的调度行为。

参数说明：

• pid：要设置调度策略和参数的进程ID。这可以是一个整数，表示进程的ID，也可以是 os.getpid() 的返回值，表示当前进程的ID。
• policy：一个整数，表示要设置的调度策略。常见的调度策略包括 os.SCHED_FIFO（先进先出）、os.SCHED_RR（轮转）和 os.SCHED_OTHER（默认调度策略）。
• param：一个可选参数，表示与调度策略相关的参数。这个参数的类型和含义取决于 policy 参数指定的调度策略。例如，对于 os.SCHED_FIFO 或 os.SCHED_RR，param 应该是一个 os.sched_param 对象，其中包含了一个 sched_priority 字段，表示进程的优先级。

需要注意的是，只有具有足够权限的用户（通常是 root 用户或具有 CAP_SYS_SCHED 能力的用户）才能更改进程的调度策略和参数。

下面是一个使用 os.sched_setscheduler() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

# 设置FIFO调度策略，并指定优先级为5
policy = os.SCHED_FIFO
param = os.sched_param(5)

try:
    # 尝试设置调度策略和参数
    os.sched_setscheduler(pid, policy, param)
    print("Successfully set scheduler policy and parameters.")
except PermissionError:
    print("Permission denied. You may need root privileges to change scheduler settings.")

在这个示例中，我们首先获取了当前进程的ID，然后设置了FIFO调度策略，并指定了优先级为5。如果成功设置了调度策略和参数，程序将输出一条成功消息。如果因为权限不足而失败，程序将捕获 PermissionError 异常，并输出一条相应的错误消息。

请注意，在实际使用中，你应该根据具体的需求和系统环境来选择合适的调度策略和参数。同时，你也需要确保你的程序具有足够的权限来更改进程的调度设置。

os.sched_getscheduler(pid, /)

os.sched_getscheduler(pid) 是 Python 的 os 模块中的一个函数，用于获取指定进程的调度策略。这个函数允许你查询一个进程的当前调度策略。

参数 pid 是一个整数，表示要查询的进程的ID。如果你想要查询当前进程的调度策略，可以使用 os.getpid() 函数来获取当前进程的ID。

os.sched_getscheduler(pid) 返回一个整数，表示进程的当前调度策略。这个整数值通常与 os 模块中定义的常量相对应，如 os.SCHED_FIFO、os.SCHED_RR、os.SCHED_OTHER 等。

下面是一个使用 os.sched_getscheduler() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

# 获取当前进程的调度策略
scheduler_policy = os.sched_getscheduler(pid)

# 输出当前进程的调度策略
if scheduler_policy == os.SCHED_FIFO:
    print("Current process uses the FIFO scheduling policy.")
elif scheduler_policy == os.SCHED_RR:
    print("Current process uses the Round Robin scheduling policy.")
elif scheduler_policy == os.SCHED_OTHER:
    print("Current process uses the default scheduling policy.")
else:
    print(f"Current process uses an unknown scheduling policy: {scheduler_policy}")

在这个示例中，我们首先获取了当前进程的ID，然后使用 os.sched_getscheduler() 函数查询了当前进程的调度策略，并根据返回的整数值输出了相应的信息。

请注意，获取进程的调度策略通常需要足够的权限，因为这是一个相对敏感的操作。如果你没有足够的权限，尝试获取其他用户的进程调度策略可能会失败。

此外，不是所有的系统都支持所有的调度策略。在调用 os.sched_getscheduler() 之前，你应该检查你的系统是否支持你想查询的调度策略。

os.sched_setparam(pid, param, /)

os.sched_setparam(pid, param) 是 Python os 模块中的一个函数，用于设置指定进程的调度参数。这个函数允许你修改已经存在的调度策略的参数，而不改变调度策略本身。

参数说明：

• pid：一个整数，表示要设置参数的进程的ID。
• param：一个 os.sched_param 对象，包含了与当前调度策略相关的参数。对于不同的调度策略，os.sched_param 对象中的字段可能具有不同的含义。例如，对于 os.SCHED_FIFO 和 os.SCHED_RR（轮转和先进先出调度策略），os.sched_param 对象中的 sched_priority 字段表示进程的优先级。

os.sched_setparam() 函数通常在你已经使用 os.sched_setscheduler() 函数设置了进程的调度策略之后使用，以进一步调整该策略的具体参数。

需要注意的是，只有具有足够权限的用户（通常是 root 用户或具有相应能力的用户）才能更改进程的调度参数。

下面是一个使用 os.sched_setparam() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

# 假设我们之前已经设置了FIFO调度策略
policy = os.SCHED_FIFO

# 创建一个sched_param对象，设置优先级为7
param = os.sched_param(7)

try:
    # 尝试设置进程的调度参数
    os.sched_setparam(pid, param)
    print("Successfully set scheduling parameters.")
except PermissionError:
    print("Permission denied. You may need root privileges to change scheduling parameters.")

在这个示例中，我们首先获取了当前进程的ID，然后创建了一个 os.sched_param 对象来设置优先级为7。接着，我们尝试使用 os.sched_setparam() 函数来设置这个进程的调度参数。如果成功设置了参数，程序将输出一条成功消息；如果因为权限不足而失败，程序将捕获 PermissionError 异常，并输出一条相应的错误消息。

请注意，如果你还没有为进程设置调度策略，或者设置的调度策略不支持你尝试设置的参数，os.sched_setparam() 函数可能会失败。在使用这些函数时，你应该仔细查阅相关文档，以确保你的代码适用于你的操作系统和进程的需求。

os.sched_getparam(pid, /)

os.sched_getparam(pid) 是 Python os 模块中的一个函数，用于获取指定进程的调度参数。这个函数允许你查询一个已经设置了特定调度策略的进程的当前调度参数。

参数 pid 是一个整数，表示要查询调度参数的进程ID。

调用 os.sched_getparam(pid) 会返回一个 os.sched_param 对象，该对象包含了与进程当前调度策略相关的参数。对于不同的调度策略，os.sched_param 对象中的字段可能具有不同的含义。例如，对于 os.SCHED_FIFO 和 os.SCHED_RR（轮转和先进先出调度策略），os.sched_param 对象中的 sched_priority 字段表示进程的优先级。

下面是一个使用 os.sched_getparam() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

try:
    # 尝试获取当前进程的调度参数
    param = os.sched_getparam(pid)
    
    # 输出调度参数
    print(f"Scheduling parameters for process {pid}:")
    print(f"  sched_priority: {param.sched_priority}")
except PermissionError:
    print("Permission denied. You may need root privileges to get scheduling parameters.")
except OSError as e:
    print(f"An error occurred: {e}")

在这个示例中，我们首先获取了当前进程的ID，然后使用 os.sched_getparam() 函数来获取该进程的调度参数。如果成功获取了参数，我们将输出一个包含 sched_priority 字段值的消息。如果因为权限不足或其他错误而失败，程序将捕获相应的异常并输出错误消息。

请注意，只有具有足够权限的用户（通常是 root 用户或具有相应能力的用户）才能获取其他用户的进程调度参数。对于非特权用户，只能获取自己进程的调度参数。此外，如果进程没有设置调度策略或者没有与当前调度策略相关的参数，os.sched_getparam() 可能会失败。

os.sched_rr_get_interval(pid, /)

os.sched_rr_get_interval(pid) 是 Python 的 os 模块中的一个函数，用于获取指定实时轮转（Round Robin, RR）调度策略进程的时间片长度。这个函数返回的是进程在 RR 调度策略下每次获得 CPU 时间片的长度，通常以秒为单位。

参数 pid 是一个整数，表示要查询时间片长度的进程ID。

os.sched_rr_get_interval() 返回一个包含两个浮点数的元组，第一个数字是时间片长度的秒数部分，第二个数字是纳秒部分。这个时间片长度是进程在 RR 调度策略下被分配的最大 CPU 时间。当进程使用完这个时间片后，调度器会将其放到队列的末尾，等待下一次轮转。

下面是一个使用 os.sched_rr_get_interval() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

# 确保当前进程使用RR调度策略
try:
    os.sched_setscheduler(pid, os.SCHED_RR)
except PermissionError:
    print("Permission denied. You may need root privileges to set the scheduling policy.")
    exit(1)

try:
    # 获取RR调度策略下当前进程的时间片长度
    interval = os.sched_rr_get_interval(pid)
    seconds, nanoseconds = interval
    print(f"Time slice for process {pid} under Round Robin scheduling: {seconds} seconds and {nanoseconds} nanoseconds.")
except OSError as e:
    print(f"An error occurred: {e}")

在这个示例中，我们首先尝试将当前进程的调度策略设置为 os.SCHED_RR。如果成功，我们调用 os.sched_rr_get_interval() 来获取时间片长度，并将其打印出来。如果由于权限不足或其他错误而无法获取时间片长度，程序将捕获相应的异常并输出错误消息。

请注意，不是所有的系统都支持 RR 调度策略，而且更改进程的调度策略和获取时间片长度通常需要相应的权限。

os.sched_yield()

os.sched_yield() 是 Python os 模块中的一个函数，用于主动放弃当前进程的 CPU 执行权，使得其他具有相同或更高优先级的进程可以获得执行机会。

当你调用 os.sched_yield() 时，当前进程会立即放弃 CPU，并将其返回到操作系统的调度队列中。这意味着如果有其他进程在等待 CPU 时间片，它们将有机会获得执行。这在实现协程、多线程编程或需要主动让出 CPU 控制权的场景中非常有用。

需要注意的是，os.sched_yield() 的行为可能会受到操作系统调度策略的影响。在某些调度策略下，即使调用了 os.sched_yield()，当前进程也可能立即重新获得 CPU 执行权。此外，os.sched_yield() 只有在进程具有 CPU 时间片并且正在运行时才会起作用；如果进程处于阻塞状态（例如等待 I/O 操作完成），则调用 os.sched_yield() 将不会有任何效果。

下面是一个使用 os.sched_yield() 的简单示例：

import os
import time

def worker():
    for i in range(5):
        print(f"Working... {i}")
        time.sleep(1)  # 模拟一些工作
        os.sched_yield()  # 主动放弃 CPU 控制权

# 创建并启动一个工作线程
import threading
thread = threading.Thread(target=worker)
thread.start()

# 主线程继续执行其他任务
print("Main thread is doing other work...")
time.sleep(6)  # 等待工作线程完成

# 等待工作线程结束
thread.join()
print("Worker thread has finished.")

在这个示例中，我们创建了一个工作线程，该线程在执行一些模拟工作后会调用 os.sched_yield() 来主动放弃 CPU 控制权。主线程则继续执行其他任务。通过这种方式，我们可以实现并发执行多个任务，并且让工作线程在适当的时候主动让出 CPU，以便其他线程有机会执行。

需要注意的是，os.sched_yield() 的效果可能因操作系统和调度策略的不同而有所差异。在某些情况下，它可能不如使用更高级的并发控制机制（如线程、进程或异步 I/O）来得有效。

os.sched_setaffinity(pid, mask, /)

os.sched_setaffinity(pid, mask) 是 Python os 模块中的一个函数，用于设置指定进程的 CPU 亲和性（CPU affinity）。CPU 亲和性是一种调度约束，它定义了一个进程可以在哪些 CPU 核心上运行。

参数 pid 是要设置 CPU 亲和性的进程ID，通常是一个整数。参数 mask 是一个位掩码，用于指定进程可以运行的 CPU 核心集合。这个掩码通常是通过 os.cpu_count() 函数获取 CPU 核心数量，并使用位运算来构建。

通过调整 CPU 亲和性，可以将进程绑定到特定的 CPU 核心或核心组上运行，以提高性能或进行某些资源管理。例如，在某些情况下，将进程绑定到特定的核心可以避免跨核心缓存失效，从而提高缓存命中率。

下面是一个使用 os.sched_setaffinity() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

# 获取系统可用的 CPU 核心数量
cpu_count = os.cpu_count()

# 创建一个掩码，表示进程可以在所有 CPU 核心上运行
# 在这个例子中，我们假设 CPU 核心是从 0 开始编号的
affinity_mask = (1 << cpu_count) - 1

try:
    # 设置当前进程的 CPU 亲和性
    os.sched_setaffinity(pid, affinity_mask)
    print(f"Set affinity for process {pid} to run on all {cpu_count} CPUs.")
except PermissionError:
    print("Permission denied. You may need root privileges to set CPU affinity.")
except OSError as e:
    print(f"An error occurred: {e}")

在这个示例中，我们首先获取当前进程的ID和系统可用的 CPU 核心数量。然后，我们创建一个掩码，其中每个位都设置为 1，表示进程可以在所有核心上运行。最后，我们调用 os.sched_setaffinity() 来设置当前进程的 CPU 亲和性。

请注意，设置 CPU 亲和性通常需要相应的权限。在大多数系统中，只有特权用户（如 root 用户）才能为其他用户的进程设置 CPU 亲和性。此外，不是所有的系统都支持 CPU 亲和性设置，因此在使用此功能时应检查其可用性。

os.sched_getaffinity(pid, /)

os.sched_getaffinity(pid) 是 Python os 模块中的一个函数，用于获取指定进程的 CPU 亲和性设置。CPU 亲和性定义了哪些 CPU 核心可用于运行该进程。通过这个函数，你可以知道一个进程被允许在哪些 CPU 核心上运行。

参数 pid 是要查询 CPU 亲和性的进程ID，通常是一个整数。如果不提供 pid，则默认查询当前进程的 CPU 亲和性。

os.sched_getaffinity() 返回一个位掩码，其中每个位对应一个 CPU 核心。如果某个位被设置（即值为1），那么该进程被允许在该核心上运行。位掩码的长度通常与系统中可用的 CPU 核心数量相同。

下面是一个使用 os.sched_getaffinity() 的示例：

import os

# 获取当前进程的ID
pid = os.getpid()

try:
    # 获取当前进程的CPU亲和性掩码
    affinity_mask = os.sched_getaffinity(pid)
    
    # 获取系统可用的CPU核心数量
    cpu_count = os.cpu_count()
    
    # 打印CPU亲和性信息
    print(f"Process {pid} has the following CPU affinity mask: {affinity_mask}")
    print(f"The process can run on {bin(affinity_mask).count('1')} out of {cpu_count} available CPUs.")
    
    # 将掩码转换为CPU核心编号的列表
    affine_cpus = [i for i in range(cpu_count) if (affinity_mask & (1 << i))]
    print(f"The process can run on CPU cores: {affine_cpus}")

except OSError as e:
    print(f"An error occurred: {e}")

在这个示例中，我们首先获取当前进程的ID，然后使用 os.sched_getaffinity() 来获取该进程的 CPU 亲和性掩码。接下来，我们计算系统中可用的 CPU 核心数量，并打印出进程可以运行的 CPU 核心数量。最后，我们通过遍历掩码中的每个位来确定进程可以在哪些具体的 CPU 核心上运行，并将这些核心编号打印出来。

请注意，获取 CPU 亲和性通常需要适当的权限。在大多数情况下，只有特权用户（如 root 用户）才能查询其他用户的进程的 CPU 亲和性。此外，不是所有的系统都支持获取 CPU 亲和性，因此在使用此功能时应检查其可用性。

os.confstr(name, /)

os.confstr(name) 是 Python os 模块中的一个函数，用于获取与配置相关的系统字符串。这个函数提供了一种方式来查询操作系统中的特定配置信息。

参数 name 是一个字符串，它指定了你想要查询的系统配置的名称。这个名称通常是一个预定义的常量，它对应于你想要查询的特定系统配置。例如，os.confstr(‘CS_PATH’) 可以返回用于执行 shell 命令的搜索路径。

下面是一些可能的 name 参数值及其含义：

• CS_PATH: 用于执行 shell 命令的搜索路径。
• CS_VPATH: 用于查找可执行文件的虚拟路径。
• CS_SHELL: 用于执行 shell 命令的 shell 名称。

请注意，os.confstr() 函数在不同的操作系统上可能有不同的行为和可用性。不是所有的配置名称都在所有的系统上可用，因此调用一个不存在或不受支持的配置名称可能会引发异常。

下面是一个使用 os.confstr() 的示例：

import os

# 获取用于执行 shell 命令的搜索路径
shell_path = os.confstr('CS_PATH')
print(f"Shell search path: {shell_path}")

# 尝试获取一个可能不存在的配置名称
try:
    unknown_config = os.confstr('UNKNOWN_CONFIG_NAME')
    print(f"Unknown config value: {unknown_config}")
except OSError as e:
    print(f"Error: {e}")

在这个示例中，我们尝试获取用于执行 shell 命令的搜索路径，并打印出来。然后，我们尝试获取一个不存在的配置名称，这将引发一个 OSError 异常，因为我们查询的配置名称不受支持或不存在。

请注意，os.confstr() 函数的具体行为和可用性可能会因操作系统的不同而有所差异。在使用这个函数时，最好查阅相关的操作系统文档或 Python 官方文档，以了解该函数在你所使用的操作系统上的具体行为。