linux 如何组织进程的,Linux操作系统进程模型分析进程

Linux操作系统简介

Linux拥有现代操作系统的功能，如真正的抢先式多任务处理，支持多用户内存，保护虚拟内存，支持SMP、UP，符合POSIX 标准联网、图形用户接口和桌面环境具有快速性、稳定性等特点。本文通过分析Linux内核源代码，说明了Linux作为操作系统内核是如何对进程组织，转换，调度的。

进程的组织

进程在内核中是以PCB的形式存在的，一个操作系统有很多进程，即就是很多PCB同时存在，如何有效的管理进程的组织方式，显然是一个很重要的问题，为了遍历内核中所有的进程，内核将这些PCB直接用双向链表链起来，task_struct 结构中的tasks字段就是用来连接所有进程描述符的。在这个链中，链表头是init_task描述符，它是所谓的0进程或者swapper进程的描述符，init_task.tasks.prev字段指向链表中最后插入的进程描述符的tasks字段。

structtask_struct {structlist_head run_list;structlist_head tasks;struct task_struct *real_parent; /*real parent process (when being debugged)*/

struct task_struct *parent; /*parent process*/

struct list_head children; /*list of my children*/

struct list_head sibling; /*linkage in my parent's children list*/

struct task_struct *group_leader; /*threadgroup leader*/

/*PID/PID hash table linkage.*/

structpid_link pids[PIDTYPE_MAX];structlist_head thread_group;

｝；

从以上源代码中的字段可知Linux是如何组织进程的。

字段run_list：

在内核中有一个队列是可运行队列，即就是保存了进程状态为：TASK_RUNNING的进程PCB，这个队列就是run_list字段，内核为每个优先级都设置了一个可运行队列，即如果一个进程的优先级为k(取值范围是0到139)，那么内核就将此进程链入到优先权为k的可运行队列中，这样CPU可以从高优先级可可运行队列去选择要运行的进程，这样提高了效率，但为此却要把所有可运行的进程队列拆分成140个不同的队列。这些队列有一个单独的数据结构prio_array_t数据结构 来实现，定义如下(摘自linux2.6.11)：

typedef structprio_array prio_array_t;structprio_array {

unsignedintnr_active;

unsignedlongbitmap[BITMAP_SIZE];structlist_head queue[MAX_PRIO];

};

字段 children、 sibling和thread_group：

这三个字段分别是进程的子进程链表、兄弟链表和线程组链表。可以根据children和sibling字段找到一个进程家族的进程。进程在创建后必须处于某一个组中，通过thread_group来形成一个进程组。

进程的转换

Linux中进程切换过程与函数调用堆栈基本类似

void my_schedule(void)

{

tPCB*next;

tPCB*prev;if(my_current_task ==NULL|| my_current_task->next ==NULL)

{return;

}

printk(KERN_NOTICE">>>my_schedule<<next;

prev=my_current_task;/*进程上下文的切换，与函数调用堆栈类似*/

if(next->state == 0)/*-1 unrunnable, 0 runnable, >0 stopped*/{/*switch to next process*/asmvolatile(/*保存当前进程的ebp esp*/

"pushl %%ebp\n\t" /*save ebp*/

"movl %%esp,%0\n\t" /*save esp*/

/*构建下一个进程的esp*/

"movl %2,%%esp\n\t" /*restore esp*/

/*$1f是指下面标号为1的位置，就是下一个进程启动的位置*/

"movl $1f,%1\n\t" /*save eip*/

/*下一个进程eip压栈*/

"pushl %3\n\t"

/*恢复现场:eip指向下下个进程的地址ebp恢复为第一条指令压栈保存的ebp*/

"ret\n\t" /*restore eip*/

"1:\t" /*next process start here*/

"popl %%ebp\n\t":"=m" (prev->thread.sp),"=m" (prev->thread.ip)

:"m" (next->thread.sp),"m" (next->thread.ip)

);

my_current_task=next;

printk(KERN_NOTICE">>>switch %d to %d<<pid,next->pid);

}else{

next->state = 0;//新的进程设置为正在运行状态

my_current_task =next;

printk(KERN_NOTICE">>>switch %d to %d<<pid,next->pid);/*switch to new process*/asmvolatile("pushl %%ebp\n\t" /*save ebp*/

"movl %%esp,%0\n\t" /*save esp*/

/*新的进程从来没有执行过，所以栈为空esp与ebp指向同一位置*/

"movl %2,%%esp\n\t" /*restore esp*/

"movl %2,%%ebp\n\t" /*restore ebp*/

"movl $1f,%1\n\t" /*save eip*/

"pushl %3\n\t"

"ret\n\t" /*restore eip*/:"=m" (prev->thread.sp),"=m" (prev->thread.ip)

:"m" (next->thread.sp),"m" (next->thread.ip)

);

}return;

}

切换过程：

1.保存当前进程的堆栈环境(esp,eip,ebp)，首先将当前进程的ebp压栈，并将esp和eip保存在当前进程的结构体中

2.构建下一进程的堆栈环境。然后下一条进程的thread.sp读出，赋给esp;thread.ip读出赋给eip。若下一条进程是新的进程，处于未运行状态，则新进程堆栈为空，esp与ebp指向同一地址，这种情况与函数调用堆栈更加类似。若下一条进程处于运行态，那么ebp与当前进程的ebp指向同一地址。

3.恢复堆栈环境，为下下个进程做准备。恢复eip,即把执行完成的进程的thread.ip(下一进程的指令地址)赋给eip，上例中所有进程的thread.ip设为my_process。

如图所示：

进程的调度

Linux系统进程提供了两种优先级，一种是普通的进程优先级，第二个是实时优先级。前者适用SCHED_NORMAL调度策略，后者可选SCHED_FIFO或SCHED_RR调度策略。任何时候，实时进程的优先级都高于普通进程，实时进程只会被更高级的实时进程抢占，同级实时进程之间是按照FIFO(一次机会做完)或者RR(多次轮转)规则调度的。

Linux进程状态机：

个人看法

在日常使用手机或者电脑的时候，经常在将应用关闭或退出后，仍然还有许多进程在后台运行，促使我对进程的存在产生了好奇心。现在明白，不仅仅在应用运行时会产生进程，计算机系统本身在运行过程中也会产生许多进程，就是这些进程使得计算机可以调用许多功能，与人进行交互。而通过对Linux操作系统进程的探索，使我对进程有了更进一步的了解，懂得了为什么计算机可以同时运行那么多程序，好的进程的组织，转换和调用模式可以极大地提升计算机的性能，帮助我们更好地完成任务。