1. 将系所有的就绪线程按照 FCFS 原则，排成一个就绪队列。
    2. 每次调度时将 CPU 分派（dispatch）给队首进程，让其执行一个时间片。
    3. 在时钟中断时，统计比较当前线程时间片是否已经用完。 　- 如用完，则调度器（scheduler）暂停当前进程的执行，将其送到就绪队列的末尾，并通过切换执行就绪队列的队首进程。 　- 如没用完，则线程继续使用。
    3. use alloc::vec::Vec;
    5. #[derive(Default)]
    6. struct RRInfo {
    7.     valid: bool,
    8.     time: usize,
    9.     prev: usize,
    10.     next: usize,
    11. }
    13. pub struct RRScheduler {
    14.     threads: Vec<RRInfo>,
    15.     max_time: usize,
    16.     current: usize,
    17. }
    19. impl RRScheduler {
    20.     // 设置每个线程连续运行的最大 tick 数
    21.     pub fn new(max_time_slice: usize) -> Self {
    22.         let mut rr = RRScheduler {
    23.             threads: Vec::default(),
    24.             max_time: max_time_slice,
    25.             current: 0,
    26.         };
    27.         rr.threads.push(
    28.             RRInfo {
    29.                 time: 0,
    30.                 prev: 0,
    32.             }
    33.         );
    34.         rr
    35.     }
    36. }
    37. impl Scheduler for RRScheduler {
    38.     // 分为 1. 新线程 2. 时间片耗尽被切换出的线程 两种情况
    39.     fn push(&mut self, tid : Tid) {
    40.         let tid = tid + 1;
    41.         if tid + 1 > self.threads.len() {
    42.             self.threads.resize_with(tid + 1, Default::default);
    43.         }
    45.         if self.threads[tid].time == 0 {
    46.             self.threads[tid].time = self.max_time;
    47.         }
    49.         let prev = self.threads[0].prev;
    50.         self.threads[tid].valid = true;
    51.         self.threads[prev].next = tid;
    52.         self.threads[tid].prev = prev;
    53.         self.threads[0].prev = tid;
    54.         self.threads[tid].next = 0;
    55.     }
    57.     fn pop(&mut self) -> Option<Tid> {
    58.         let ret = self.threads[0].next;
    59.         if ret != 0 {
    60.             let next = self.threads[ret].next;
    62.             self.threads[prev].next = next;
    63.             self.threads[ret].prev = 0;
    64.             self.threads[ret].next = 0;
    65.             self.threads[ret].valid = false;
    66.             self.current = ret;
    67.             Some(ret-1)
    68.         }else{
    69.             None
    70.         }
    71.     }
    73.     // 当前线程的可用时间片 -= 1
    74.     fn tick(&mut self) -> bool{
    75.         let tid = self.current;
    76.         if tid != 0 {
    77.             self.threads[tid].time -= 1;
    78.             if self.threads[tid].time == 0 {
    79.                 return true;
    80.             }else{
    81.                 return false;
    82.             }
    83.         }
    84.         return true;
    85.     }
    87.     fn exit(&mut self, tid : Tid) {
    88.         let tid = tid + 1;
    89.         if self.current == tid {
    90.             self.current = 0;
    91.         }