进程的调度算法、task_struct结构体、虚拟内存

1. 先来先服务 （FCFS，first come first served） 
   在所有调度算法中，最简单的是非抢占式的FCFS算法。 
   算法原理：进程按照它们请求CPU的顺序使用CPU.就像你买东西去排队，谁第一个排，谁就先被执行，在它执行的过程中，不会中断它。当其他人也想进入内存被执行，就要排队等着，如果在执行过程中出现一些事，他现在不想排队了，下一个排队的就补上。此时如果他又想排队了，只能站到队尾去。 
   算法优点：易于理解且实现简单，只需要一个队列(FIFO)，且相当公平 
   算法缺点：比较有利于长进程，而不利于短进程，有利于CPU 繁忙的进程，而不利于I/O 繁忙的进程

2. 最短作业优先（SJF, Shortest Job First） 
   短作业优先（SJF, Shortest Job First）又称为“短进程优先”SPN(Shortest Process Next)；这是对FCFS算法的改进，其目标是减少平均周转时间。 
   算法原理：对预计执行时间短的进程优先分派处理机。通常后来的短进程不抢先正在执行的进程。 
   算法优点：相比FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提高系统的吞吐量。 
   算法缺点：对长进程非常不利，可能长时间得不到执行，且未能依据进程的紧迫程度来划分执行的优先级，以及难以准确估计进程的执行时间，从而影响调度性能。

3. 最高响应比优先法(HRRN，Highest Response Ratio Next) 
   最高响应比优先法(HRRN，Highest Response Ratio Next)是对FCFS方式和SJF方式的一种综合平衡。FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。因此，这两种调度算法在某些极端情况下会带来某些不便。HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。这样，即使是长作业，随着它等待时间的增加，W / T也就随着增加，也就有机会获得调度执行。这种算法是介于FCFS和SJF之间的一种折中算法。 
   算法原理：响应比R定义如下： R =(W+T)/T = 1+W/T 
   其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。 
   算法优点：由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRRN方式时其吞吐量将小于采用SJF 法时的吞吐量。 
   算法缺点：由于每次调度前要计算响应比，系统开销也要相应增加。

4. 时间片轮转算法（RR，Round-Robin） 
   该算法采用剥夺策略。时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法，又称RR调度。每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间。 
   算法原理：让就绪进程以FCFS 的方式按时间片轮流使用CPU 的调度方式，即将系统中所有的就绪进程按照FCFS 原则，排成一个队列，每次调度时将CPU 分派给队首进程，让其执行一个时间片，时间片的长度从几个ms 到几百ms。在一个时间片结束时，发生时钟中断，调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程，进程可以未使用完一个时间片，就出让CPU（如阻塞）。 
   算法优点：时间片轮转调度算法的特点是简单易行、平均响应时间短。 
   算法缺点：不利于处理紧急作业。在时间片轮转算法中，时间片的大小对系统性能的影响很大，因此时间片的大小应选择恰当 
   怎样确定时间片的大小：

   时间片大小的确定 
   1.系统对响应时间的要求 
   2.就绪队列中进程的数目 
   3.系统的处理能力

5. 多级反馈队列(Multilevel Feedback Queue) 
   多级反馈队列调度算法是一种CPU处理机调度算法，UNIX操作系统采取的便是这种调度算法。 
   多级反馈队列调度算法描述： 
   　　1、进程在进入待调度的队列等待时，首先进入优先级最高的Q1等待。 
   　　2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程，则调度次优先级队列中的进程。例如：Q1,Q2,Q3三个队列，只有在Q1中没有进程等待时才去调度Q2，同理，只有Q1,Q2都为空时才会去调度Q3。 
   　　3、对于同一个队列中的各个进程，按照时间片轮转法调度。比如Q1队列的时间片为N，那么Q1中的作业在经历了N个时间片后若还没有完成，则进入Q2队列等待，若Q2的时间片用完后作业还不能完成，一直进入下一级队列，直至完成。 
   　　4、在低优先级的队列中的进程在运行时，又有新到达的作业，那么在运行完这个时间片后，CPU马上分配给新到达的作业（抢占式）。 
   

   　　在多级反馈队列调度算法中，如果规定第一个队列的时间片略大于多数人机交互所需之处理时间时，便能够较好的满足各种类型用户的需要。

6. 进程就是程序动态运行的实例，它是承担分配系统资源的实体。我们也可以把进程当成是由一组元素组成的实体，进程的两个基本的元素时程序代码和与代码相关联的数据集合。在进程执行时，都可以被表征为一下元素：

7. • 标识符：与进程相关的唯一标识符，用来区别正在执行的进程和其他进程。
   • 状态：描述进程的状态，因为进程有挂起，阻塞，运行等好几个状态，所以都有个标识符来记录进程的执行状态。
   • 优先级：如果有好几个进程正在执行，就涉及到进程被执行的先后顺序的问题，这和进程优先级这个标识符有关。
   • 程序计数器：程序中即将被执行的下一条指令的地址。
   • 内存指针：程序代码和进程相关数据的指针。
   • 上下文数据：进程执行时处理器的寄存器中的数据。
   • I/O状态信息：包括显示的I/O请求，分配给进程的I/O设备和被进程使用的文件列表等。
   • 记账信息：包括处理器的时间总和，记账号等等。

   上面的内容可以参考《操作系统精髓与设计原理》。

   操作系统对进程的控制就是通过对上面的这些元素的控制来控制操作系统的，但这些信息都不是单独存放的，而是存放在一个叫做PCB(进程控制块)数据结构中，这个数据结构是一种结构体，由操作系统创建和管理，下面我们就通过了解一下task_struct来看一看操作系统是怎么通过进程控制块来对进程进行控制和调度的吧。

   2：task_struct源码成员解析

   首先我们直接附上task_struct所定义在的头文件sched.h的链接吧： 
   http://lxr.free-electrons.com/source/include/linux/sched.h

   关于task_struct的实现大家可以参考源码！ 
   下面我们就来介绍一下tast_struct中复杂的成员吧：

   进程状态

   volatile long state;/* -1 unrunnable, 0 runnable, >0 stopped */

   • 1

   上面这个变量就是描述进程状态的成员，结合C语言我们学到的知识volatile关键字是降低编译器对代码的优化，是state变量一直从变量的内存中读取内容而不是寄存器；从而保证对操作系统状态实时访问的稳定性。

   state成员的可能取值如下

    /*
     * Task state bitmask. NOTE! These bits are also
     * encoded in fs/proc/array.c: get_task_state().
     *
     * We have two separate sets of flags: task->state
     * is about runnability, while task->exit_state are
     * about the task exiting. Confusing, but this way
     * modifying one set can't modify the other one by
     * mistake.
     */
    #define TASK_RUNNING            0
    #define TASK_INTERRUPTIBLE      1
    #define TASK_UNINTERRUPTIBLE    2
    #define TASK_STOPPED            4
    #define TASK_TRACED             8
   
   /* in tsk->exit_state */
    #define EXIT_DEAD               16
    #define EXIT_ZOMBIE             32
    #define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)
   
   /* in tsk->state again */
    #define TASK_DEAD               64
    #define TASK_WAKEKILL           128    /** wake on signals that are deadly **/
    #define TASK_WAKING             256
    #define TASK_PARKED             512
    #define TASK_NOLOAD             1024
    #define TASK_STATE_MAX          2048
   
    /* Convenience macros for the sake of set_task_state */
   #define TASK_KILLABLE           (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
   #define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
   #define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12
   • 13
   • 14
   • 15
   • 16
   • 17
   • 18
   • 19
   • 20
   • 21
   • 22
   • 23
   • 24
   • 25
   • 26
   • 27
   • 28
   • 29
   • 30
   • 31
   • 32
   • 33

   我们可以看到变量定义后面的注释，它说明变量内容<0是不运行的，=0是运行状态，>0是停止状态。 
   下面我们介绍几个常用的取值：

   状态	描述
   TASK_RUNNING	表示进程正在执行或者处于准备执行的状态
   TASK_INTERRUPTIBLE	进程因为等待某些条件处于阻塞（挂起的状态），一旦等待的条件成立，进程便会从该状态转化成就绪状态
   TASK_UNINTERRUPTIBLE	意思与TASK_INTERRUPTIBLE类似，但是我们传递任意信号等不能唤醒他们，只有它所等待的资源可用的时候，他才会被唤醒。
   TASK_STOPPED	进程被停止执行
   TASK_TRACED	进程被debugger等进程所监视。
   EXIT_ZOMBIE	进程的执行被终止，但是其父进程还没有使用wait()等系统调用来获知它的终止信息，此时进程成为僵尸进程
   EXIT_DEAD	进程被杀死，即进程的最终状态。
   TASK_KILLABLE	当进程处于这种可以终止的新睡眠状态中，它的运行原理类似于 TASK_UNINTERRUPTIBLE，只不过可以响应致命信号

   进程标识符

   pid_t pid;     //进程的标识符
   pid_t tgid;    //线程组标识符

   • 1
   • 2

   进程标识符就不用解释了，它的引入是为了区别每个进程；tgid的引入是由于Unix程序员希望同一组线程具有相同的pid所以就引入了tgid.

   进程标记符

   unsigned int flags; /* per process flags, defined below */ 

   • 1

   flags反应进程的状态信息，用于内核识别当前进程的状态。

   它的取值范围如下：

    /*
   * Per process flags
   */
   #define PF_EXITING      0x00000004      /* getting shut down */
   #define PF_EXITPIDONE   0x00000008      /* pi exit done on shut down */
   #define PF_VCPU         0x00000010      /* I'm a virtual CPU */
   #define PF_WQ_WORKER    0x00000020      /* I'm a workqueue worker */
   #define PF_FORKNOEXEC   0x00000040      /* forked but didn't exec */
   #define PF_MCE_PROCESS  0x00000080      /* process policy on mce errors */
   #define PF_SUPERPRIV    0x00000100      /* used super-user privileges */
   #define PF_DUMPCORE     0x00000200      /* dumped core */
   #define PF_SIGNALED     0x00000400      /* killed by a signal */
   #define PF_MEMALLOC     0x00000800      /* Allocating memory */
   #define PF_NPROC_EXCEEDED 0x00001000    /* set_user noticed that RLIMIT_NPROC was exceeded */
   #define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
   #define PF_USED_ASYNC   0x00004000      /* used async_schedule*(), used by module init */
   #define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
   #define PF_FROZEN       0x00010000      /* frozen for system suspend */
   #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
   #define PF_KSWAPD       0x00040000      /* I am kswapd */
   #define PF_MEMALLOC_NOIO 0x00080000     /* Allocating memory without IO involved */
   #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
   #define PF_KTHREAD      0x00200000      /* I am a kernel thread */
   #define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
   #define PF_SWAPWRITE    0x00800000      /* Allowed to write to swap */
   #define PF_NO_SETAFFINITY 0x04000000    /* Userland is not allowed to meddle with cpus_allowed */
   #define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
   #define PF_MUTEX_TESTER 0x20000000      /* Thread belongs to the rt mutex tester */
   #define PF_FREEZER_SKIP 0x40000000      /* Freezer should not count it as freezable */
   #define PF_SUSPEND_TASK 0x80000000      /* this thread called freeze_processes and should not be frozen */

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12
   • 13
   • 14
   • 15
   • 16
   • 17
   • 18
   • 19
   • 20
   • 21
   • 22
   • 23
   • 24
   • 25
   • 26
   • 27
   • 28
   • 29
   • 30

   我们还是介绍常用的状态吧：

   状态	描述
   PF_FORKNOEXEC	表示进程刚被创建，但还没有执行
   PF_SUPERPRIV	表示进程拥有超级用户特权
   PF_SIGNALED	表示进程被信号杀出
   PF_EXITING	表示进程开始关闭

   表示进程亲属关系的成员

   /*
    * pointers to (original) parent process, youngest child, younger sibling,
    * older sibling, respectively.  (p->father can be replaced with
    * p->real_parent->pid)
    */
   struct task_struct __rcu *real_parent; /* real parent process */
   struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
   /*
    * children/sibling forms the list of my natural children
    */
   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 */

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12
   • 13

   成员	描述
   real_parent	指向当前操作系统执行进程的父进程，如果父进程不存在，指向pid为1的init进程
   paren	指向当前进程的父进程，当当前进程终止时，需要向它发送wait4()的信号
   children	位于链表的头部，链表的所有元素都是children的子进程
   group_leader	指向进程组的领头进程

   ptrace系统调用

   Ptrace提供了一种父进程，它可以被用来控制子进程的运行，常被用来进行断点调试，当它被设置为0时表示不需要追踪。

   /*
    * Ptrace flags
    *
    * The owner ship rules for task->ptrace which holds the ptrace
    * flags is simple.  When a task is running it owns it's task->ptrace
    * flags.  When the a task is stopped the ptracer owns task->ptrace.
    */
   
   #define PT_SEIZED       0x00010000      /* SEIZE used, enable new behavior */
   #define PT_PTRACED      0x00000001
   #define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
   #define PT_PTRACE_CAP   0x00000004      /* ptracer can follow suid-exec */
   
   #define PT_OPT_FLAG_SHIFT       3
   /* PT_TRACE_* event enable flags */
   #define PT_EVENT_FLAG(event)    (1 << (PT_OPT_FLAG_SHIFT + (event)))
   #define PT_TRACESYSGOOD         PT_EVENT_FLAG(0)
   #define PT_TRACE_FORK           PT_EVENT_FLAG(PTRACE_EVENT_FORK)
   #define PT_TRACE_VFORK          PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
   #define PT_TRACE_CLONE          PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
   #define PT_TRACE_EXEC           PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
   #define PT_TRACE_VFORK_DONE     PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
   #define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
   #define PT_TRACE_SECCOMP        PT_EVENT_FLAG(PTRACE_EVENT_SECCOMP)
   
   #define PT_EXITKILL             (PTRACE_O_EXITKILL << PT_OPT_FLAG_SHIFT)
   #define PT_SUSPEND_SECCOMP      (PTRACE_O_SUSPEND_SECCOMP << PT_OPT_FLAG_SHIFT)
   
   /* single stepping state bits (used on ARM and PA-RISC) */
   #define PT_SINGLESTEP_BIT       31
   #define PT_SINGLESTEP           (1<
   #define PT_BLOCKSTEP_BIT        30
   #define PT_BLOCKSTEP            (1<

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12
   • 13
   • 14
   • 15
   • 16
   • 17
   • 18
   • 19
   • 20
   • 21
   • 22
   • 23
   • 24
   • 25
   • 26
   • 27
   • 28
   • 29
   • 30
   • 31
   • 32
   • 33

   进程调度

   优先级

   int prio, static_prio, normal_prio;
   unsigned int rt_priority;

   • 1
   • 2

   成员	描述
   static_prio	用来保存静态优先级，可以调用nice系统直接来修改取值范围为100~139
   rt_priority	用来保存实时优先级,取值范围为0~99
   prio	用来保存动态优先级
   normal_prio	它的值取决于静态优先级和调度策略

   实时优先级和静态优先级的取值范围中，值越大，优先级越低

   进程地址空间

   进程都拥有自己的资源，这些资源指的就是进程的地址空间，每个进程都有着自己的地址空间，在task_struct中，有关进程地址空间的定义如下：

   struct mm_struct *mm, *active_mm;
   /* per-thread vma caching */
   u32 vmacache_seqnum;
   struct vm_area_struct *vmacache[VMACACHE_SIZE];
   #if defined(SPLIT_RSS_COUNTING)
   struct task_rss_stat    rss_stat;
   #endif
   
   /*  http://lxr.free-electrons.com/source/include/linux/sched.h?V=4.5#L1484  */
   #ifdef CONFIG_COMPAT_BRK
   unsigned brk_randomized:1;
   #endif

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12

   成员	描述
   mm	进程所拥有的内存空间描述符，对于内核线程的mm为NULL
   active_mm	指进程运行时所使用的进程描述符
   rss_stat	被用来记录缓冲信息

   如果当前内核线程被调度之前运行的也是另外一个内核线程时候，那么其mm和avtive_mm都是NULL

   总结：有关进程控制块task_struct大家暂时可以先了解这么多，在后期我会继续更新有关进程控制块方面的内容，总之，操作系统对进程的调度依赖于进程控制块，操作系统在创建进程时也会自动创建进程控制块，进程切换，进程的创建和终止，都和进程控制块有关~

   
   

8. 1、什么是进程（Process）和线程（Thread）？有何区别？

   　　进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

   　　进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。

   　　2、Windows下的内存是如何管理的？

   　　Windows提供了3种方法来进行内存管理：虚拟内存，最适合用来管理大型对象或者结构数组；内存映射文件，最适合用来管理大型数据流（通常来自文件）以及在单个计算机上运行多个进程之间共享数据；内存堆栈，最适合用来管理大量的小对象。

   　　Windows操纵内存可以分两个层面：物理内存和虚拟内存。

   　　其中物理内存由系统管理，不允许应用程序直接访问，应用程序可见的只有一个2G地址空间，而内存分配是通过堆进行的。对于每个进程都有自己的默认堆，当一个堆创建后，就通过虚拟内存操作保留了相应大小的地址块（不占有实际的内存，系统消耗很小）。当在堆上分配一块内存时，系统在堆的地址表里找到一个空闲块（如果找不到，且堆创建属性是可扩充的，则扩充堆大小），为这个空闲块所包含的所有内存页提交物理对象（在物理内存上或硬盘的交换文件上），这时就可以访问这部分地址。提交时，系统将对所有进程的内存统一调配，如果物理内存不够，系统试图把一部分进程暂时不访问的页放入交换文件，以腾出部分物理内存。释放内存时，只在堆中将所在的页解除提交（相应的物理对象被解除），继续保留地址空间。

   　　如果要知道某个地址是否被占用/可不可以访问，只要查询此地址的虚拟内存状态即可。如果是提交，则可以访问。如果仅仅保留，或没保留，则产生一个软件异常。此外，有些内存页可以设置各种属性。如果是只读，向内存写也会产生软件异常。

   　　3、Windows消息调度机制是？

   　　A）指令队列；B）指令堆栈；C）消息队列；D）消息堆栈

   　　答案：C

   　　处理消息队列的顺序。首先Windows绝对不是按队列先进先出的次序来处理的，而是有一定优先级的。优先级通过消息队列的状态标志来实现的。首先，最高优先级的是别的线程发过来的消息（通过sendmessage）；其次，处理登记消息队列消息；再次处理QS_QUIT标志，处理虚拟输入队列，处理wm_paint；最后是wm_timer。

   　　4、描述实时系统的基本特性

   　　在特定时间内完成特定的任务，实时性与可靠性。

   　　所谓“实时操作系统”，实际上是指操作系统工作时，其各种资源可以根据需要随时进行动态分配。由于各种资源可以进行动态分配，因此，其处理事务的能力较强、速度较快。

   　　5、中断和轮询的特点

   　　对I/O设备的程序轮询的方式，是早期的计算机系统对I/O设备的一种管理方式。它定时对各种设备轮流询问一遍有无处理要求。轮流询问之后，有要求的，则加以处理。在处理I/O设备的要求之后，处理机返回继续工作。尽管轮询需要时间，但轮询要比I/O设备的速度要快得多，所以一般不会发生不能及时处理的问题。当然，再快的处理机，能处理的输入输出设备的数量也是有一定限度的。而且，程序轮询毕竟占据了CPU相当一部分处理时间，因此，程序轮询是一种效率较低的方式，在现代计算机系统中已很少应用。

   　　程序中断通常简称中断，是指CPU在正常运行程序的过程中，由于预先安排或发生了各种随机的内部或外部事件，使CPU中断正在运行的程序，而转到为响应的服务程序去处理。

   　　轮询——效率低，等待时间很长，CPU利用率不高。

   　　中断——容易遗漏一些问题，CPU利用率高。
   
   

   　6、什么是临界区？如何解决冲突？

   　　每个进程中访问临界资源的那段程序称为临界区，每次只准许一个进程进入临界区，进入后不允许其他进程进入。

   　　（1）如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入；

   　　（2）任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区，则其它所有试图进入临界区的进程必须等待；

   　　（3）进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区；

   　　（4）如果进程不能进入自己的临界区，则应让出CPU，避免进程出现“忙等”现象。

   　　7、说说分段和分页

   　　页是信息的物理单位，分页是为实现离散分配方式，以消减内存的外零头，提高内存的利用率；或者说，分页仅仅是由于系统管理的需要，而不是用户的需要。

   　　段是信息的逻辑单位，它含有一组其意义相对完整的信息。分段的目的是为了能更好的满足用户的需要。

   　　页的大小固定且由系统确定，把逻辑地址划分为页号和页内地址两部分，是由机器硬件实现的，因而一个系统只能有一种大小的页面。段的长度却不固定，决定于用户所编写的程序，通常由编辑程序在对源程序进行编辑时，根据信息的性质来划分。

   　　分页的作业地址空间是一维的，即单一的线性空间，程序员只须利用一个记忆符，即可表示一地址。分段的作业地址空间是二维的，程序员在标识一个地址时，既需给出段名，又需给出段内地址。

   　　8、说出你所知道的保持进程同步的方法？

   　　进程间同步的主要方法有原子操作、信号量机制、自旋锁、管程、会合、分布式系统等。

   　　9、Linux中常用到的命令

   　　显示文件目录命令ls        如ls

   　　改变当前目录命令cd        如cd /home

   　　建立子目录mkdir           如mkdir xiong

   　　删除子目录命令rmdir       如rmdir /mnt/cdrom

   　　删除文件命令rm            如rm /ucdos.bat

   　　文件复制命令cp            如cp /ucdos /fox

   　　获取帮助信息命令man      如man ls

   　　显示文件的内容less        如less mwm.lx

   　　重定向与管道type          如type readme>>direct，将文件readme的内容追加到文direct中
   

   10、Linux文件属性有哪些？（共十位）

   　　-rw-r--r--那个是权限符号，总共是- --- --- ---这几个位。

   　　第一个短横处是文件类型识别符：-表示普通文件；c表示字符设备（character）；b表示块设备（block）；d表示目录（directory）；l表示链接文件（link）；后面第一个三个连续的短横是用户权限位（User），第二个三个连续短横是组权限位（Group），第三个三个连续短横是其他权限位（Other）。每个权限位有三个权限，r（读权限），w（写权限），x（执行权限）。如果每个权限位都有权限存在，那么满权限的情况就是：-rwxrwxrwx；权限为空的情况就是- --- --- ---。

   　　权限的设定可以用chmod命令，其格式位：chmod ugoa+/-/=rwx filename/directory。例如：

   　　一个文件aaa具有完全空的权限- --- --- ---。

   　　chmod u+rw aaa（给用户权限位设置读写权限，其权限表示为：- rw- --- ---）

   　　chmod g+r aaa（给组设置权限为可读，其权限表示为：- --- r-- ---）

   　　chmod ugo+rw aaa（给用户，组，其它用户或组设置权限为读写，权限表示为：- rw- rw- rw-）

   　　如果aaa具有满权限- rwx rwx rwx。

   　　chmod u-x aaa（去掉用户可执行权限，权限表示为：- rw- rwx rwx）

   　　如果要给aaa赋予制定权限- rwx r-x r-x，命令为：

   　　chmod u=rwx，Go=rx aaa

   　　11、makefile文件的作用是什么？

   　　一个工程中的源文件不计其数，其按类型、功能、模块分别放在若干个目录中。makefile定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。makefile带来的好处就是——“自动化编译”。一旦写好，只需要一个make命令，整个工程完全自动编译，极大地提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具。一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。

   　　12、简术OSI的物理层Layer1，链路层Layer2，网络层Layer3的任务。

   　　网络层：通过路由选择算法，为报文或分组通过通信子网选择最适当的路径。

   　　链路层：通过各种控制协议，将有差错的物理信道变为无差错的、能可靠传输数据帧的数据链路。

   　　物理层：利用传输介质为数据链路层提供物理连接，实现比特流的透明传输。

   　　13、什么是中断？中断时CPU做什么工作？

   　　中断是指在计算机执行期间，系统内发生任何非寻常的或非预期的急需处理事件，使得CPU暂时中断当前正在执行的程序而转去执行相应的事件处理程序。待处理完毕后又返回原来被中断处继续执行或调度新的进程执行的过程。

   　　14、你知道操作系统的内容分为几块吗？什么叫做虚拟内存？他和主存的关系如何？内存管理属于操作系统的内容吗？

   　　操作系统的主要组成部分：进程和线程的管理，存储管理，设备管理，文件管理。虚拟内存是一些系统页文件，存放在磁盘上，每个系统页文件大小为4K，物理内存也被分页，每个页大小也为4K，这样虚拟页文件和物理内存页就可以对应，实际上虚拟内存就是用于物理内存的临时存放的磁盘空间。页文件就是内存页，物理内存中每页叫物理页，磁盘上的页文件叫虚拟页，物理页+虚拟页就是系统所有使用的页文件的总和。

   　15、线程是否具有相同的堆栈？dll是否有独立的堆栈？

   　　每个线程有自己的堆栈。

   　　dll是否有独立的堆栈？这个问题不好回答，或者说这个问题本身是否有问题。因为dll中的代码是被某些线程所执行，只有线程拥有堆栈。如果dll中的代码是exe中的线程所调用，那么这个时候是不是说这个dll没有独立的堆栈？如果dll中的代码是由dll自己创建的线程所执行，那么是不是说dll有独立的堆栈？

   　　以上讲的是堆栈，如果对于堆来说，每个dll有自己的堆，所以如果是从dll中动态分配的内存，最好是从dll中删除；如果你从dll中分配内存，然后在exe中，或者另外一个dll中删除，很有可能导致程序崩溃。

   　　16、什么是缓冲区溢出？有什么危害？其原因是什么？

   　　缓冲区溢出是指当计算机向缓冲区内填充数据时超过了缓冲区本身的容量，溢出的数据覆盖在合法数据上。

   　　危害：在当前网络与分布式系统安全中，被广泛利用的50%以上都是缓冲区溢出，其中最著名的例子是1988年利用fingerd漏洞的蠕虫。而缓冲区溢出中，最为危险的是堆栈溢出，因为入侵者可以利用堆栈溢出，在函数返回时改变返回程序的地址，让其跳转到任意地址，带来的危害一种是程序崩溃导致拒绝服务，另外一种就是跳转并且执行一段恶意代码，比如得到shell，然后为所欲为。通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，使程序转而执行其它指令，以达到攻击的目的。

   　　造成缓冲区溢出的主原因是程序中没有仔细检查用户输入的参数。

   　　17、什么是死锁？其条件是什么？怎样避免死锁？

   　　死锁的概念：在两个或多个并发进程中，如果每个进程持有某种资源而又都等待别的进程释放它或它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组进程产生了死锁。通俗地讲，就是两个或多个进程被无限期地阻塞、相互等待的一种状态。

   　　死锁产生的原因主要是：？ 系统资源不足；？ 进程推进顺序非法。

   　　产生死锁的必要条件：

   　　（1）互斥（mutualexclusion），一个资源每次只能被一个进程使用；

   　　（2）不可抢占（nopreemption），进程已获得的资源，在未使用完之前，不能强行剥夺；

   　　（3）占有并等待（hold andwait），一个进程因请求资源而阻塞时，对已获得的资源保持不放；

   　　（4）环形等待（circularwait），若干进程之间形成一种首尾相接的循环等待资源关系。

   　　这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

   　　死锁的解除与预防：理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。

   　　死锁的处理策略：鸵鸟策略、预防策略、避免策略、检测与恢复策略。