blocks|key|121776|text|澄清:我对“CPU时间片的可调度单元”的理解是“可以在给定的CPU时间片中调度的单元”(因为如果“可调度单元”是一个时间，那么这个问题对我来说就没有多大意义)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|121777|基于此，简单地说，对于给定的逻辑核，“CPU时间片的可调度单元”可以看作是一个软件线程(更具体地说，它的执行上下文由寄存器和进程信息组成)。|offset|length|style|BOLD|121778|操作系统调度器在任务上运行。任务可以是线程、进程或其他不寻常的结构(例如。(数据流)。|121779|现代主流操作系统主要在处理单元(通常是硬件线程，也称为逻辑核)上调度线程、。您可以获得有关Windows调度程序如何在Microsoft文档中工作的更多信息。文件明确指出：|121780|线程是进程中可以调度执行的实体。|blockquote|121781|在Linux上，默认的调度程序CFS在任务+(即。task_struct数据结构)。任务可以是线程、一组线程或进程。这样做是为了使调度程序更通用，也是因为这个调度器是很久以前设计的，当时处理器只有一个核心，人们只关注进程而不是线程。自从多核时代以来，应用程序就使用了大量的线程，所以可以使用可用的内核。因此，现在，实际调度AFAIK的通常是线程。这在著名的研究论文：浪费十年的核心中得到了解释(这篇论文也解释了CFS对于目标处理器是如何工作的)。|CODE|121782|请注意，术语"process“有时可以指线程，因为线程有时被称为”轻量级进程“，而基本进程有时被称为”重进程“。过程甚至可以是重型和轻量级过程的通用术语(即。线程和实际进程)。这是一个非常令人困惑的术语，也是对语言的误用(就像“处理器”一词有时用于核心)。在实践中，这在特定的上下文中通常不是一个问题，因为线程和进程可以互换使用(在这种情况下，人们应该使用像“任务”这样的通用术语)。|121783|至于“CPU时间片的可调度单元”，这要复杂一些。一个简单而又天真的答案是:线程(它绝对不是单独的进程)。也就是说，线程是一个软件定义的概念(就像进程一样)。它基本上是一个堆栈、少量寄存器和一个父进程(可能包含一些元信息和一个TLS空间)。CPU不直接对这种数据结构进行操作。例如，CPU没有线程堆栈的概念(与任何其他部分一样，它只是虚拟进程内存的一部分)。它们只需要一个由寄存器和进程配置(在保护模式中)组成的执行上下文。为了简单起见，我们可以说它们执行线程。主流的现代x86处理器非常复杂，每个核心通常能够同时运行多个线程。这叫做同时多线程+(又名。(英特尔处理器的超线程处理)。x86物理核通常由两个逻辑线程(即。硬件线程)，每个线程都可以执行一个软件线程。|121784|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads|1|https://en.wikipedia.org/wiki/Completely_Fair_Scheduler|2|https://elixir.bootlin.com/linux/latest/source/include/linux/sched.h#L728|3|https://people.ece.ubc.ca/sasha/papers/eurosys16-final29.pdf|4|https://en.wikipedia.org/wiki/Protected_mode|5|https://en.wikipedia.org/wiki/Simultaneous_multithreading^0|0|I|P|0|8|2|0|Y|3|1N|B|0|0|0|P|B|F|3|1|J|2|2|52|8|3|0|0|5G|4|4|7E|5|5|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@$D|1N|E|1O|1|1P]]|A|$]]|$1|L|3|M|5|N|7|1Q|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1R|8|@$D|1S|E|1T|F|Q]]|9|@$D|1U|E|1V|1|1W]|$D|1X|E|1Y|1|1Z]|$D|20|E|21|1|22]]|A|$]]|$1|R|3|S|5|6|7|23|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|24|8|@]|9|@$D|25|E|26|1|27]|$D|28|E|29|1|2A]]|A|$]]|$1|V|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]|13|$5|Y|Z|10|A|$11|14]]|15|$5|Y|Z|10|A|$11|16]]|17|$5|Y|Z|10|A|$11|18]]|19|$5|Y|Z|10|A|$11|1A]]|1B|$5|Y|Z|10|A|$11|1C]]]]

Clarification: my understanding of &quot;a schedulable unit of CPU time slice&quot; is &quot;a unit that can be scheduled during a given CPU time slice&quot; (since if &quot;schedulable unit&quot; would be a time then the question does not make much sense to me).
Based on this, put it shortly, &quot;a schedulable unit of CPU time slice&quot; for a given logical core can be seen as a software thread (more specifically its execution context composed of registers and process information).
<hr />
Operating systems scheduler operates on tasks. Tasks can be threads, processes, or other unusual structure (eg. dataflows).
Modern mainstream operating system mainly schedule threads on processing units (typically hardware threads also called logical cores). You can get more information about how the Windows scheduler works in the <a href="https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads" rel="nofollow noreferrer">Microsoft documentation</a>. The documentation explicitly states:
<blockquote>
A thread is the entity within a process that can be scheduled for execution
</blockquote>
On Linux, the default scheduler, <a href="https://en.wikipedia.org/wiki/Completely_Fair_Scheduler" rel="nofollow noreferrer">CFS</a>, operates on <a href="https://elixir.bootlin.com/linux/latest/source/include/linux/sched.h#L728" rel="nofollow noreferrer">task</a> (ie. <code>task_struct</code> data structure). Tasks can be a thread, a group of threads or a process. This was done that way so to make the scheduler more generic and also because this scheduler was designed long ago, when processors had only 1 core and people focused on processes rather than thread. The multi-core era since caused applications to use a lot of threads so to use available cores. As a result, nowadays, it is generally threads that are actually scheduled AFAIK. This is explained in the famous research paper <a href="https://people.ece.ubc.ca/sasha/papers/eurosys16-final29.pdf" rel="nofollow noreferrer">The Linux Scheduler: a Decade of Wasted Cores</a> (which also explain a bit how the CFS operate regarding the target processor).
Note that the term &quot;process&quot; can sometime refer to a thread since threads are sometime called &quot;lightweight processes&quot; and basic processes are sometime called &quot;heavy processes&quot;. Processes can even be a generic term for both heavy and lightweight processes (ie. threads and actual processes). This is a very confusing terminology and a misuse of language (like the term &quot;processors&quot; sometimes used for cores). In practice, this is often not a problem in a specific context since threads and processes may be used interchangeably though (in such a case, people should use a generic term like &quot;tasks&quot;).
As for &quot;a schedulable unit of CPU time slice&quot; this is a bit more complex. A simple and naive answer is: a thread (it is definitively not processes alone). That being said, a thread is a software-defined concept (like processes). It is basically a stack, few registers, and a parent process (with possibly some meta-information and a TLS space). CPUs does not operate directly on such data structure. CPU does not have a concept of thread stack for example (it is just a section of the virtual process memory like any other). They just need an execution context which is composed of registers and a process configuration (in <a href="https://en.wikipedia.org/wiki/Protected_mode" rel="nofollow noreferrer">protected mode</a>). For sake of simplicity, we can say that they execute threads. Mainstream modern x86 processors are very complex, and each core is often able to run multiple threads at the same time. This is called <a href="https://en.wikipedia.org/wiki/Simultaneous_multithreading" rel="nofollow noreferrer">simultaneous multithreading</a> (aka. Hyper-Threading for Intel processors). x86 physical cores are typically composed of two logical threads (ie. hardware threads) that can each execute a software threads.

blocks|key|1212118|text|时间片是一个时间单位，例如，在用HZ=100构建的传统Linux内核中有10+ms+(每秒100个定时器中断)。在一个任务在CPU核心上运行了那么长时间之后，内核恢复对该CPU的控制，并调用schedule()来决定这个CPU核心接下来应该运行的任务；它已经在运行的任务，或者一个不同的任务。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1212119|当外部中断出现时，调度程序也可以更早地运行，特别是在当前时间间隔的末尾:如果有一个更高优先级的任务正在等待CPU，例如在等待I/O或sleep()系统调用结束后，操作系统将其调度到这个核心上是有意义的，而不是完成任何被中断的CPU任务的时间段。|1212120|任务是一个有用的词，用于调度程序必须从中挑选的东西。而不是在进程中暗示单独的进程或线程，也没有为内核任务留出空间，比如Linux中断处理程序的“下半部分”，即不是线程或进程。|BOLD|1212121|进程的每个线程都需要单独调度，以便在CPU核心上执行(如果没有阻塞的话)。|1212122|您发现的有关调度过程的文章使用的是简化的假设，即每个进程都是单线程的。|1212123|或者他们假设一个1:n的线程模型，其中操作系统只知道整个进程的一个任务，而多线程是在用户空间"绿线“而不是本机线程中完成的。现在大多数主流OSes使用1:1线程模型，其中每个C%2B%2B或Java线程都是操作系统可见的单独的可调度任务，尽管n:m模型在有多个操作系统调度任务的情况下是可能的，但没有高级语言线程那么多。|1212124|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Green_threads^0|2N|A|0|1U|7|0|0|2|0|0|0|1B|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|18|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

A time slice is a unit of time, for example 10 ms in a traditional Linux kernel built with HZ=100 (100 timer interrupts per second). After a task has been running for that long on a CPU core, the kernel regains control on that CPU and calls <code>schedule()</code> to decide what task this CPU core should run next; the task it was already running, or a different task.
The scheduler can also run earlier if an external interrupt comes in, especially near the end of the current timeslice: if there's a higher-priority task that's now waiting for a CPU, e.g. after waiting for I/O or after a <code>sleep()</code> system call ended, it makes sense for the OS to schedule it onto this core, instead of finishing the time-slice of whatever CPU-bound task was interrupted.
<hr />
Task is a useful word for the things the scheduler has to pick from. Without implying separate process or threads within a process, and also leaving room for kernel tasks like a Linux interrupt handler &quot;bottom half&quot; that aren't threads or processes.
Every thread of a process needs to get scheduled separately to execute on a CPU core (if it's not blocked).
The articles you found about scheduling processes is using the simplifying assumption that each process is single-threaded.
Or they're assuming a 1:n threading model, where the OS is only aware of one task for the whole process, and multithreading is done in user-space, &quot;<a href="https://en.wikipedia.org/wiki/Green_threads" rel="nofollow noreferrer">green threads</a>&quot; instead of native threads. Most mainstream OSes these days use a 1:1 threading model, where every C++ or Java thread is a separately schedulable task visible to the OS, although n:m models are possible where you have multiple OS-scheduled tasks, but not as many as you have high-level-language threads.

I want to clarify whether &quot;a schedulable unit of CPU time slice&quot; is &quot;process&quot; or &quot;thread&quot; (kernel managed thread). What I mean by &quot;schedulable unit of CPU time slice&quot; is the unit which CPU scheduler of an operating system allocates CPU time slice.
According to &quot;<a href="https://en.wikipedia.org/wiki/Scheduling_(computing)" rel="nofollow noreferrer">Short-term scheduling</a>&quot; in wikipedia, process is used to refer the schedulable unit.
<blockquote>
&quot;This scheduler can be preemptive, implying that it is capable of forcibly removing processes from a CPU when it decides to allocate that CPU to another process&quot;
</blockquote>
Also, according to &quot;<a href="https://en.wikipedia.org/wiki/Preemption_(computing)" rel="nofollow noreferrer">Time slice</a>&quot; in wikepedia,
<blockquote>
&quot;The scheduler is run once every time slice to choose the next process to run.&quot;
</blockquote>
Also, according to &quot;<a href="https://en.wikipedia.org/wiki/Thread_(computing)" rel="nofollow noreferrer">Thread</a>&quot; in wikepedia,
<blockquote>
&quot;a process is a unit of resources, while a thread is a unit of scheduling and execution&quot;
</blockquote>
According to &quot;<a href="https://learn.microsoft.com/en-us/windows/win32/procthread/processes-and-threads" rel="nofollow noreferrer">Processes and Threads</a>&quot; in microsoft docs,
<blockquote>
&quot;A thread is the basic unit to which the operating system allocates processor time.&quot;
</blockquote>
According to &quot;<a href="https://www.quora.com/Is-thread-scheduling-done-by-the-CPU-kernel-or-both" rel="nofollow noreferrer">Is thread scheduling done by the CPU, kernel, or both?</a>&quot; in quora,
<blockquote>
&quot;The CPU (hardware) just carries out instructions. The CPU itself has no concept of threads or scheduling, although there may be features in the CPU that support them.
</blockquote>
<blockquote>
&quot;The operating system kernel (a set of instructions, aka software) executes on the CPU (hardware). A scheduling algorithm in the kernel of the operating system chooses which thread to execute next, and directs the CPU to begin executing the next instruction in that chosen thread&quot;.
</blockquote>

Is a schedulable unit of CPU time slice process or thread?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想澄清“CPU时间片的可调度单元”是“进程”还是“线程”(内核管理线程)。我所说的“CPU时间片的可调度单元”是操作系统的CPU调度程序分配CPU时间片的单元。根据维基百科中的“短期调度()”，进程是指可调度单元。这个调度程序可以是先发制人的，这意味着当它决定将进程分配给另一个进程时，它能够强制从CPU中删除该进程此...

问是CPU时间片进程或线程的可调度单元吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是CPU时间片进程或线程的可调度单元吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是CPU时间片进程或线程的可调度单元吗？
EN