Linux中线程调度策略：
Normal Policy：
SCHED_OTHER: Default Linux time-sharing scheduling
SCHED_OTHER can only be used at static priority 0. SCHED_OTHER is the
standard Linux time-sharing scheduler that is intended for all processes that
do not require the special real-time mechanisms. The process to run is chosen
from the static priority 0 list based on a dynamic priority that is determined
only inside this list. The dynamic priority is based on the nice value (set
by nice(2) or setpriority(2)) and increased for each time quantum the process
is ready to run, but denied to run by the scheduler. This ensures fair
progress among all SCHED_OTHER processes.
SCHED_BATCH: Scheduling batch processes
(Since Linux 2.6.16.) SCHED_BATCH can only be used at static priority 0.
This policy is similar to SCHED_OTHER in that it schedules the process
according to its dynamic priority (based on the nice value). The difference
is that this policy will cause the scheduler to always assume that the process
is CPU-intensive. Consequently, the scheduler will apply a small scheduling
penalty with respect to wakeup behavior, so that this process is mildly
disfavored in scheduling decisions.
This policy is useful for workloads that are noninteractive, but do not want
to lower their nice value, and for workloads that want a deterministic
scheduling policy without interactivity causing extra preemptions (between the
workload's tasks).
SCHED_IDLE: Scheduling very low priority jobs
(Since Linux 2.6.23.) SCHED_IDLE can only be used at static priority 0; the
process nice value has no influence for this policy.
This policy is intended for running jobs at extremely low priority (lower even
than a +19 nice value with the SCHED_OTHER or SCHED_BATCH policies).这三种调度策略只能用于 static priority为0时。调度器对SCHED_BATCH调度比SCHED_OTHER的更慢一些。如果要更详细的理解他们的区别就只能去看Linux的源代码了。
Realtime Policy：
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFO can only be used with static priorities higher than 0, which means
that when a SCHED_FIFO processes becomes runnable, it will always immediately
preempt any currently running SCHED_OTHER, SCHED_BATCH, or SCHED_IDLE process.
SCHED_FIFO is a simple scheduling algorithm without time slicing. For
processes scheduled under the SCHED_FIFO policy, the following rules apply:
* A SCHED_FIFO process that has been preempted by another process of higher
priority will stay at the head of the list for its priority and will resume
execution as soon as all processes of higher priority are blocked again.
* When a SCHED_FIFO process becomes runnable, it will be inserted at the end
of the list for its priority.
* A call to sched_setscheduler() or sched_setparam(2) will put the SCHED_FIFO
(or SCHED_RR) process identified by pid at the start of the list if it was
runnable. As a consequence, it may preempt the currently running process
if it has the same priority. (POSIX.1-2001 specifies that the process
should go to the end of the list.)
* A process calling sched_yield(2) will be put at the end of the list.
No other events will move a process scheduled under the SCHED_FIFO policy in
the wait list of runnable processes with equal static priority.
A SCHED_FIFO process runs until either it is blocked by an I/O request, it is
preempted by a higher priority process, or it calls sched_yield(2).
SCHED_RR: Round Robin scheduling
SCHED_RR is a simple enhancement of SCHED_FIFO. Everything described above
for SCHED_FIFO also applies to SCHED_RR, except that each process is only
allowed to run for a maximum time quantum. If a SCHED_RR process has been
running for a time period equal to or longer than the time quantum, it will be
put at the end of the list for its priority. A SCHED_RR process that has been
preempted by a higher priority process and subsequently resumes execution as a
running process will complete the unexpired portion of its round robin time
quantum. The length of the time quantum can be retrieved using
sched_rr_get_interval(2).
SCHED_RR与SCHED_FIFO可以使用1-99的priority值，每个priority都有一个队列与之对应。他们的区别就是SCHED_RR有时间片的概念，每个SCHED_RR的进程只能运行指定的时间，过期就会被放到priority对应的列表后面。1. 如何理解对一个进程设置调度策略，又如何理解对某个线程设置调度策略呢？
