2019-11-23 12:12:18 weixin_41112983 阅读数 15
  • 2020考研专业课《计算机操作系统原理》精讲视频课程

    计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统课程还是非常容易理解和掌握的,终在考研时取得到高分。

    67597 人正在学习 去看看 任铄

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2019-11-14 00:14:20 weixin_43913541 阅读数 85
  • 2020考研专业课《计算机操作系统原理》精讲视频课程

    计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统课程还是非常容易理解和掌握的,终在考研时取得到高分。

    67597 人正在学习 去看看 任铄

@T现代操作系统第四版参考答案

现代操作系统英文第四版第二章参考答案——进程

先更新第二章的答案,习惯中文的童鞋请左转百度翻译

Solution for chapter 2

  1. The transition from blocked to running is conceivable. Suppose that a process is blocked on I/O and the I/O finishes. If the CPU is otherwise idle, the process could go directly from blocked to running. The other missing transition, from ready to blocked, is impossible. A ready process cannot do I/O or anything else that might block it. Only a running process can block.

  2. You could have a register containing a pointer to the current process-table entry. When I/O completed, the CPU would store the current machine state in the current process-table entry. Then it would go to the interrupt vector for the interrupting device and fetch a pointer to another process-table entry (the service procedure). This process would then be started up.

  3. Generally, high-level languages do not allow the kind of access to CPU hardware that is required. For instance, an interrupt handler may be required to enable and disable the interrupt servicing a particular device, or to manipulate data within a process’ stack area. Also, interrupt service routines must execute as rapidly as possible.

  4. There are several reasons for using a separate stack for the kernel. Two of them are as follows. First, you do not want the operating system to crash because a poorly written user program does not allow for enough stack space. Second, if the kernel leaves stack data in a user program’s memory space upon return from a system call, a malicious user might be able to use this data to find out information about other processes.

  5. The chance that all five processes are idle is 1/32, so the CPU idle time is 1/32.

  6. There is enough room for 14 processes in memory. If a process has an I/O of p, then the probability that they are all waiting for I/O is p14. By equating this to 0.01, we get the equation p14 = 0. 01. Solving this, we get p = 0. 72, so we can tolerate processes with up to 72% I/O wait.

  7. If each job has 50% I/O wait, then it will take 40 minutes to complete in the absence of competition. If run sequentially, the second one will finish 80 minutes after the first one starts. With two jobs, the approximate CPU utilization is 1 − 0. 52. Thus, each one gets 0.375 CPU minute per minute of real time. To accumulate 20 minutes of CPU time, a job must run for 20/0.375 minutes, or about 53.33 minutes. Thus running sequentially the jobs finish after 80 minutes, but running in parallel they finish after 53.33 minutes.

  8. The probability that all processes are waiting for I/O is 0.46 which is 0.004096. Therefore, CPU utilization = 1 − 0. 004096 = 0: 995904.

  9. The client process can create separate threads; each thread can fetch a different part of the file from one of the mirror servers. This can help reduce downtime. Of course, there is a single network link being shared by all threads. This link can become a bottleneck as the number of threads becomes very large.

  10. It would be difficult, if not impossible, to keep the file system consistent. Suppose that a client process sends a request to server process 1 to update a file. This process updates the cache entry in its memory. Shortly thereafter, another client process sends a request to server 2 to read that file. Unfortunately, if the file is also cached there, server 2, in its innocence, will return obsolete data. If the first process writes the file through to the disk after caching it, and server 2 checks the disk on every read to see if its cached copy is up-to-date, the system can be made to work, but it is precisely all these disk accesses that the caching system is trying to avoid.

  11. No. If a single-threaded process is blocked on the keyboard, it cannot fork.

  12. A worker thread will block when it has to read a Web page from the disk. If user-level threads are being used, this action will block the entire process, destroying the value of multithreading. Thus it is essential that kernel threads are used to permit some threads to block without affecting the others.

  13. Yes. If the server is entirely CPU bound, there is no need to have multiple threads. It just adds unnecessary complexity. As an example, consider a telephone directory assistance number (like 555-1212) for an area with 1 million people. If each (name, telephone number) record is, say, 64 characters, the entire database takes 64 megabytes and can easily be kept in the server’s memory to provide fast lookup.

  14. When a thread is stopped, it has values in the registers. They must be saved, just as when the process is stopped. the registers must be saved. Multiprogramming threads is no different than multiprogramming processes, so each thread needs its own register save area.

  15. Threads in a process cooperate. They are not hostile to one another. If yielding is needed for the good of the application, then a thread will yield. After all, it is usually the same programmer who writes the code for all of them.

  16. User-level threads cannot be preempted by the clock unless the whole process’ quantum has been used up (although transparent clock interrupts can happen). Kernel-level threads can be preempted individually. In the latter case, if a thread runs too long, the clock will interrupt the current process and thus the current thread. The kernel is free to pick a different thread from the same process to run next if it so desires.

  17. In the single-threaded case, the cache hits take 12 msec and cache misses take 87 msec. The weighted average is 2/3 × 12 + 1/3 × 87. Thus, the mean request takes 37 msec and the server can do about 27 per second. For a multithreaded server, all the waiting for the disk is overlapped, so every request takes 12 msec, and the server can handle 83 1/3 requests per second.

  18. The biggest advantage is the efficiency. No traps to the kernel are needed to switch threads. The biggest disadvantage is that if one thread blocks, the entire process blocks.

  19. Yes, it can be done. After each call to pthread create, the main program could do a pthread join to wait until the thread just created has exited before creating the next thread.

  20. The pointers are really necessary because the size of the global variable is unknown. It could be anything from a character to an array of floating-point numbers. If the value were stored, one would have to giv e the size to create global, which is all right, but what type should the second parameter of set global be, and what type should the value of read global be?

  21. It could happen that the runtime system is precisely at the point of blocking or unblocking a thread, and is busy manipulating the scheduling queues. This would be a very inopportune moment for the clock interrupt handler to begin inspecting those queues to see if it was time to do thread switching, since they might be in an inconsistent state. One solution is to set a flag when the runtime system is entered. The clock handler would see this and set its own flag, then return. When the runtime system finished, it would check the clock flag, see that a clock interrupt occurred, and now run the clock handler.

  22. Yes it is possible, but inefficient. A thread wanting to do a system call first sets an alarm timer, then does the call. If the call blocks, the timer returns control to the threads package. Of course, most of the time the call will not block, and the timer has to be cleared. Thus each system call that might block has to be executed as three system calls. If timers go off prematurely, all kinds of problems develop. This is not an attractive way to build a threads package.

  23. Yes, it still works, but it still is busy waiting, of course.

  24. It certainly works with preemptive scheduling. In fact, it was designed for that case. When scheduling is nonpreemptive, it might fail. Consider the case in which turn is initially 0 but process 1 runs first. It will just loop forever and never release the CPU.

  25. The priority inversion problem occurs when a low-priority process is in its critical region and suddenly a high-priority process becomes ready and is scheduled. If it uses busy waiting, it will run forever. With user-level threads, it cannot happen that a low-priority thread is suddenly preempted to allow a high-priority thread run. There is no preemption. With kernel-level threads this problem can arise.

  26. With round-robin scheduling it works. Sooner or later L will run, and eventually it will leave its critical region. The point is, with priority scheduling, L never gets to run at all; with round robin, it gets a normal time slice periodically, so it has the chance to leave its critical region.

  27. Each thread calls procedures on its own, so it must have its own stack for the local variables, return addresses, and so on. This is equally true for user-level threads as for kernel-level threads.

  28. Yes. The simulated computer could be multiprogrammed. For example, while process A is running, it reads out some shared variable. Then a simulated clock tick happens and process B runs. It also reads out the same variable. Then it adds 1 to the variable. When process A runs, if it also adds 1 to the variable, we have a race condition.

  29. Yes, it will work as is. At a given time instant, only one producer (consumer) can add (remove) an item to (from) the buffer.

  30. The solution satisfies mutual exclusion since it is not possible for both processes to be in their critical section. That is, when turn is 0, P0 can execute its critical section, but not P1. Likewise, when turn is 1. However, this assumes P0 must run first. If P1 produces something and it puts it in a buffer, then while P0 can get into its critical section, it will find the buffer empty and block. Also, this solution requires strict alternation of the two processes, which is undesirable.

  31. To do a semaphore operation, the operating system first disables interrupts. Then it reads the value of the semaphore. If it is doing a down and the semaphore is equal to zero, it puts the calling process on a list of blocked processes associated with the semaphore. If it is doing an up, it must check to see if any processes are blocked on the semaphore. If one or more processes are blocked, one of them is removed from the list of blocked processes and made runnable. When all these operations have been completed, interrupts can be enabled again.

  32. Associated with each counting semaphore are two binary semaphores, M, used for mutual exclusion, and B, used for blocking. Also associated with each counting semaphore is a counter that holds the number of ups minus the number of downs, and a list of processes blocked on that semaphore. To implement down, a process first gains exclusive access to the semaphores, counter, and list by doing a down on M. It then decrements the counter. If it is zero or more, it just does an up on M and exits. If M is negative, the process is put on the list of blocked processes. Then an up is done on M and a down is done on B to block the process. To implement up, first M is downed to get mutual exclusion, and then the counter is incremented. If it is more than zero, no one was blocked, so all that needs to be done is to up M. If, however, the counter is now neg ative or zero, some process must be removed from the list. Finally, an up is done on B and M in that order.

  33. If the program operates in phases and neither process may enter the next phase until both are finished with the current phase, it makes perfect sense to use a barrier.

  34. With kernel threads, a thread can block on a semaphore and the kernel can run some other thread in the same process. Consequently, there is no problem using semaphores. With user-level threads, when one thread blocks on a semaphore, the kernel thinks the entire process is blocked and does not run it ever again. Consequently, the process fails.

  35. It is very expensive to implement. Each time any variable that appears in a predicate on which some process is waiting changes, the run-time system must re-evaluate the predicate to see if the process can be unblocked. With the Hoare and Brinch Hansen monitors, processes can only be awakened on a signal primitive.

  36. The employees communicate by passing messages: orders, food, and bags in this case. In UNIX terms, the four processes are connected by pipes.

  37. It does not lead to race conditions (nothing is ever lost), but it is effectively busy waiting.

  38. It will take nT sec.

  39. Three processes are created. After the initial process forks, there are two processes running, a parent and a child. Each of them then forks, creating two additional processes. Then all the processes exit.

  40. If a process occurs multiple times in the list, it will get multiple quanta per cycle. This approach could be used to give more important processes a larger share of the CPU. But when the process blocks, all entries had better be removed from the list of runnable processes.

  41. In simple cases it may be possible to see if I/O will be limiting by looking at source code. For instance a program that reads all its input files into buffers at the start will probably not be I/O bound, but a problem that reads and writes incrementally to a number of different files (such as a compiler) is likely to be I/O bound. If the operating system provides a facility such as the UNIX ps command that can tell you the amount of CPU time used by a program, you can compare this with the total time to complete execution of the program. This is, of course, most meaningful on a system where you are the only user.

  42. If the context switching time is large, then the time quantum value has to be proportionally large. Otherwise, the overhead of context switching can be quite high. Choosing large time quantum values can lead to an inefficient system if the typical CPU burst times are less than the time quantum. If context switching is very small or negligible, then the time quantum value can be chosen with more freedom.

  43. The CPU efficiency is the useful CPU time divided by the total CPU time. When Q ≥ T, the basic cycle is for the process to run for T and undergo a process switch for S. Thus, (a) and (b) have an efficiency of T/(S + T). When the quantum is shorter than T, each run of T will require T/Q process switches, wasting a time ST/Q. The efficiency here is then T /(T + ST/Q) which reduces to Q/(Q + S), which is the answer to ©. For (d), we just substitute Q for S and find that the efficiency is 50%. Finally, for (e), as Q → 0 the efficiency goes to 0.

  44. Shortest job first is the way to minimize average response time. 0<X ≤ 3: X, 3, 5, 6, 9. 3<X ≤ 5: 3, X, 5, 6, 9. 5<X ≤ 6: 3, 5, X, 6, 9. 6<X ≤ 9: 3, 5, 6, X, 9. X > 9: 3, 5, 6, 9,X.

  45. For round robin, during the first 10 minutes each job gets 1/5 of the CPU. At the end of 10 minutes, C finishes. During the next 8 minutes, each job gets 1/4 of the CPU, after which time D finishes. Then each of the three remaining jobs gets 1/3 of the CPU for 6 minutes, until B finishes, and so on. The finishing times for the five jobs are 10, 18, 24, 28, and 30, for an average of 22 minutes. For priority scheduling, B is run first. After 6 minutes it is finished. The other jobs finish at 14, 24, 26, and 30, for an average of 18.8 minutes. If the jobs run in the order A through E, they finish at 10, 16, 18, 22, and 30, for an average of 19.2 minutes. Finally, shortest job first yields finishing times of 2, 6, 12, 20, and 30, for an average of 14 minutes.

  46. The first time it gets 1 quantum. On succeeding runs it gets 2, 4, 8, and 15, so it must be swapped in 5 times.

  47. Each voice call needs 200 samples of 1 msec or 200 msec. Together they use 400 msec of CPU time. The video needs 11 msec 33 1/3 times a second for a total of about 367 msec. The sum is 767 msec per second of real time so the system is schedulable.

  48. Another video stream consumes 367 msec of time per second for a total of 1134 msec per second of real time so the system is not schedulable.

  49. The sequence of predictions is 40, 30, 35, and now 25.

  50. The fraction of the CPU used is 35/50 + 20/100 + 10/200 + x/250. To be schedulable, this must be less than 1. Thus x must be less than 12.5 msec.

  51. Yes. There will be always at least one fork free and at least one philosopher that can obtain both forks simultaneously. Hence, there will be no deadlock. You can try this for N = 2, N = 3 and N = 4 and then generalize.

  52. Each voice call runs 166.67 times/second and uses up 1 msec per burst, so each voice call needs 166.67 msec per second or 333.33 msec for the two of them. The video runs 25 times a second and uses up 20 msec each time, for a total of 500 msec per second. Together they consume 833.33 msec per second, so there is time left over and the system is schedulable.

  53. The kernel could schedule processes by any means it wishes, but within each process it runs threads strictly in priority order. By letting the user process set the priority of its own threads, the user controls the policy but the kernel handles the mechanism.

  54. If a philosopher blocks, neighbors can later see that she is hungry by checking his state, in test, so he can be awakened when the forks are available.

  55. The change would mean that after a philosopher stopped eating, neither of his neighbors could be chosen next. In fact, they would never be chosen. Suppose that philosopher 2 finished eating. He would run test for philosophers 1 and 3, and neither would be started, even though both were hungry and both forks were available. Similarly, if philosopher 4 finished eating, philosopher 3 would not be started. Nothing would start him.

  56. Variation 1: readers have priority. No writer may start when a reader is active. When a new reader appears, it may start immediately unless a writer is currently active. When a writer finishes, if readers are waiting, they are all started, regardless of the presence of waiting writers. Variation 2: Writers have priority. No reader may start when a writer is waiting. When the last active process finishes, a writer is started, if there is one; otherwise, all the readers (if any) are started. Variation 3: symmetric version. When a reader is active, new readers may start immediately. When a writer finishes, a new writer has priority, if one is waiting. In other words, once we have started reading, we keep reading until there are no readers left. Similarly, once we have started writing, all pending writers are allowed to run.

  57. A possible shell script might be
    if[!-f numbers ]; then echo 0 > numbers; fi
    count = 0;
    while (test $count !=200)
    do
    count = ‘expr 4count + 1’
    n=‘tail -1 numbers’
    expr $n +1 >>number
    done
    Run the script twice simultaneously, by starting it once in the background (using &) and again in the foreground. Then examine the file numbers. It will probably start out looking like an orderly list of numbers, but at some point it will lose its orderliness, due to the race condition created by running two copies of the script. The race can be avoided by having each copy of the script test for and set a lock on the file before entering the critical area, and unlocking it upon leaving the critical area. This can be done like this:

    if In numbers numbers.lock
    then 
    	n='tail -1 numbers'
    	expr $n +1 >>numbers 
    	rm numbers.lock
    fi
    

This version will just skip a turn when the file is inaccessible. Variant solutions could put the process to sleep, do busy waiting, or count only loops in which the operation is successful.

56以后属于开放性题目,留给读者练习发挥的空间。

2019-06-09 20:47:37 weixin_43342945 阅读数 841
  • 2020考研专业课《计算机操作系统原理》精讲视频课程

    计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统课程还是非常容易理解和掌握的,终在考研时取得到高分。

    67597 人正在学习 去看看 任铄

计算机操作系统操作系统(第四版)汤小丹版
思维导图(第一章到第七章)

这是百度脑图分享的链接,里面有源文件可以下载,可以自己修改
http://naotu.baidu.com/file/830bb9dad96752f2af29c24c4c23e351?token=9c4011994b2c70f0
在这里插入图片描述

2018-09-08 23:01:26 qq475703980 阅读数 12370
  • 2020考研专业课《计算机操作系统原理》精讲视频课程

    计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统课程还是非常容易理解和掌握的,终在考研时取得到高分。

    67597 人正在学习 去看看 任铄

如有错误答案,请各位评论指出,多谢多谢~~

1、图2-2中给出了三个进程状态,在理论上,三个状态可以有六种转换,每个状态两个。但是,图中只给出了四种转换。有没有可能发生其他两种转换中的一个或两个?

从阻塞到运行的转换是可以想象的。假设某个进程在I/O上阻塞,而且I/O结束,如果此时CPU空闲,该进程就可以从阻塞态直接转到运行态。而另外一种转换(从就绪态到阻塞)是不可能的。一个就绪进程是不可能不做任何事情就直接阻塞,必定要经过运行这一个状态。

2.假设要设计一种先进的计算机体系结构,它使用硬件而不是中断来完成进程切换。CPU需要哪些信息?请描述用硬件完成进程切换的工作过程。

应该有一个寄存器包含当前进程表项的指针。当I/O结束时,CPU将把当前的机器状态存入到当前进程表项中。然后,将转到中断设备的中断向量,读取另一个进程表项的指针(服务例程),然后,就可以启动这个进程了。

3、在所有当代计算机中,至少有部分中断处理程序是用汇编语言编写的。为什么?

通常,高级语言不允许访问CPU硬件,而这种访问是必需的。例如,中断处理程序可能需要禁用和启用某个特定设备的中断服务,或者处理进程堆栈区的数据。另外,中断服务例程需要尽快地执行。

4、当中断或系统调用把控制转给操作系统时,通常将内核堆栈和被中断进程的运行堆栈分离。为什么?

内核使用单独的堆栈有若干的原因。其中两个原因如下:

  • 首先,不希望操作系统崩溃,由于某些用户程序不允许足够的堆栈空间。
  • 第二,如果内核将数据保留在用户空间,然后从系统调用返回,那么恶意的用户可能使用这些数据找出某些关于其它进程的信息。

5、一个计算机系统的内存有足够的空间容纳5个程序。这些程序又一半时间处于等待I/O的空闲状态。请问CPU时间浪费的比例是多少?

五个进程都空闲的概率是1/32,所以CPU空闲时间是1/32。

6、一个计算机的RAM有4GB,其中操作系统占512M。所有进程都占256M并且特征相同。要是CPU利用率达到99%, 最大I/O等待是多少?

内存中有足够的空间容纳14个进程。如果一个进程的I/O是P,那么它们都在等待I/O的概率是P 14。通过将其等于0.01,我们得到方程p 14=0。01。解决这个问题,我们得到p=0。72,因此我们可以容忍高达72%I/O等待的进程

7、多个作业能够并行运行,比它们顺序执行完成的要快。假设有两个作业同时开始执行,每个需要10分钟的CPU时间。如果顺序执行,那么最后一个作业需要多长时间可以完成?如果并行执行又需要多长时间?假设I/O等待占50%。

CPU利用率计算公式:CPU利用率 = 1 - p^n 。设运行作业所需要的时间为T。

如果每个工作都有50%的I/O等待,那么在没有竞争的情况下,完成该工作需要40分钟。如果按顺序运行,第二个将在第一个启动后80分钟完成。对于两个作业,CPU利用率大约为1-0.5^2。因此,每一个系统每分钟可获得0.375 cpu分钟的实时数据。要累积20分钟的CPU时间,作业必须运行20/0.375分钟,或大约53.33分钟。因此,按顺序运行的作业在80分钟后完成,但并行运行的作业在53.33分钟后完成。

8、考虑一个6级多道程序系统(内存可同时容纳6个程序)。假设每个进程I/O等待时间40%,那么CPU利用率是多少?

所有进程等待I/O的概率为0.4^6,即0.004096。因此,CPU利用率=1−0。004096=0:995904。

9、假设要从互联网去哪个上下载一个2GB大小文件,文件内容可以从一组镜像服务器获得,每个服务器可以传输文件的一部分,假定每个传输请求给定开始字节可结束字节,如何用多线程优化下载?

客户机进程可以创建单独的线程;每个线程可以从一个镜像服务器获取文件的不同部分。这有助于减少停机时间。当然,所有线程都共享一个网络链接。当线程数量变得非常大时,此链接可能成为瓶颈。

10、为什么图2-11a的模式不适合用于使用内存高速缓存的文件服务器。为什么不适合?每个进程可以有自己的高速缓存吗?

即使是有可能实现,也是很难保持文件系统的一致性。假设某个客户进程给服务器进程1发送请求要更新文件。该进程更新其内存的cache项。然后,另一个客户进程给服务器进程2发送请求读取该文件。不幸的是,如果该文件还在 cache中,服务器进程2对此毫不知情,将返回过时的数据。如果第一个进程在缓冲后将文件写到磁盘中, 而服务器进程2每次读取时检查磁盘其缓存的备份是否是最新的,系统还可以工作,但是需要避免磁盘访问的所有缓存系统。

11、当一个多线程进程创建子进程时,若子进程得到全部父进程线程的副本,会出现问题。假如原有线程之一正在等待键盘输入,现在则成为两个线程在等待键盘输入,每个进程有一个。在单线程进程中也会发生这种问题吗?

不会。如果单线程进程在键盘上阻塞,就不能创建子进程。

12、在图2-8中,给出了一个多线程Web服务器。如果读取文件的惟一途径是正常的阻塞read系统调用,那么Web服务器应该使用用户级线程还是内核级线程?为什么?

当工作者线程从磁盘读取Web页时,它就会被阻塞。如果使用用户级线程,该动作将阻塞整个进程,而破坏多线程的价值。这就是使用内核线程的原因:某些线程的阻塞不会影响到其他线程。

13、在本章中,我们介绍了多线程Web服务器,说明它比单线程服务器和有限状态机服务器更好的原因。存在单线程服务器更好一些的情形吗?请给出一个例子。

是的。如果服务器是完全CPU绑定的,则不需要多线程。这只会增加不必要的复杂性。假设某个百万人口区域的电话查号系统(类似于114),如果每个(姓名,电话号码)记录为64个字符,整个的数据库则为64MB,这就很容易全部读入服务器内存中以提供快速的查询。

14、既然计算机中只有一套寄存器,为什么图2-12中寄存器集合按每个线程中的内容列出而不是按每个进程中的内容列出?

当一个线程停止时,它在寄存器中有值。它们必须被保存,就像进程停止时,必须保存寄存器。多线程和多进程没有什么不同,所以每个线程需要自己的寄存器保存区。

15、在没有时钟中段的系统中,一个县城放弃CPU后可能再也不会获得CPU资源,那么为什么线程还要通过thread_yield自愿放弃CPU?

进程中的线程合作。它们彼此不敌对。如果应用程序需要阻塞以运行得更好,那么一个线程可以调用thread_yield自愿放弃CPU。毕竟,同一个进程中的线程的全部代码通常是一个程序员写的。

16、线程可以被时钟中断抢占吗?如果可以,在什么情况下可以?如果不可以,为什么不可以?

17、请对使用单线程服务器和多线程服务器读取文件进行比较。假设所需要的数据都在块高速缓存中,花费15ms获得工作请求,分派工作,并处理其余必要工作。如果在三分之一时间时,需要一个磁盘操作,要另外花费75ms,此时该线程进入睡眠。在单线程情形下服务器每秒钟可以处理多少个请求?如果是多线程呢?

在单线程情况下,cache命中需15ms,cache未命中需要90ms。其加权平均为2/315+1/390。因此,平均请求为40ms,而服务器每秒可处理25个。对于多线程服务器,所有磁盘等待都是重叠的,因此每个请求都耗时15ms,而服务器每秒可处理66.6666个请求。

18.在用户空间实现线程,其最大的优点是什么?最大的缺点是什么?

最大的优势就是效率。不需要陷入内核来切换线程。最大的缺点是,如果一个线程阻塞,整个进程都会阻塞。

19、在图2-15中创建线程和线程打印消息是随机交织在一起的。有没有方法可以严格按照以下次序运行:创建线程1,线程1打印消息,线程1结束,创建线程2,线程2打印消息,线程2结束,以此类推;如果有,是什么方法,如果没有请解释原因。

是的,这是可以做到的。每次执行pthread_create后,主程序可以调用pthread_join等待刚刚创建的线程退出后再创建下一个线程。

20、在讨论线程中的全局变量时,曾使用过程create_global将存储分配给指向变量的指针,而不是变量自身。这是必需的,还是由于该过程也需要使用这些值?

指针是确实必要的,因为全局变量的大小是未知的。它可能是从字符到浮点数数组的任何类型。如果保存其值,就不得不把其大小传递给create_global,这都没有问题,但是必须将其类型作为set_global的第二个参数,那么read_global返回值的类型是什么呢。

21、考虑一个线程线程全部在用户空间实现的系统,该运行时系统每秒钟得到一个时钟中断。假设在该运行时系统中,当某个线程正在执行时发生一个时钟中断,此时会出现什么问题?你有什么解决该问题的建议吗?

答:runtime系统可以正好在这一时刻阻塞或者解除阻塞某个线程,并且忙于处理调度队列。此时并不适合于时钟中断处理程序开始检查该队列是否应该进行线程切换,因为它们可能处于不一致的状态。解决方法可以是:当进入runtime系统后,设置一个标志。时钟处理程序将看到该标志,并且设置其自己的标志,然后返回。当runtime系统完成时,它将检测时钟标志,看是否有时钟中断发生,并且现在运行时钟处理程序。

22、假设一个操作系统中不存在类似于select的系统调用来提前了解在从文件、管道或设备中读取时是否安全,不过该操作系统确实允许设置报警时钟,以便中断阻塞的系统调用。在上述条件下,是否有可能在用户空间中实现一个线程包?请讨论。

这是可能的,不过效率很低。线程想要做一个系统调用,首先设定警报定时器,然后才执行调用。如果线程阻塞,定时器将控制归还给线程包。当然,大多数调用是不阻塞的,而定时器必须被清除。每个可能被阻塞的系统调用都必须作为3个系统调用来执行。如果定时器过早失效,各种问题都可能发生。用这种方法建立线程包并不好。

23、两个进程在一个共享内存的多处理器(两个CPU)上运行,当他们要共享一块内存是,图2-23中按使用turn变量的忙等待解决方案还有效吗?

是的,它仍然有效,但当然还在忙着等待。

24、在抢占式进程调度的条件下,图2-24中互斥问题的Peterson解法可行吗?如果是非抢占式呢?

它肯定适用于抢占式调度。 实际上,它是为那种情况而设计的。 当调度是非抢占式时,它可能会失败。 考虑转弯最初为0但过程1首先运行的情况。 它将永远循环,永远不会释放CPU。

25、在2.3.4节中所讨论的优先级反转问题是否可能在用户级线程中发生?为什么?

当低优先级进程位于其临界区,而高优先级进程就绪并且被调度时,将发生优先级倒置问题。如果使用忙等待,高优先级进程将一直运行。对于用户级线程,不可能发生低优先级线程突然被剥夺而允许高优先级线程运行,因为是不可剥夺的。而内核级线程,就会出现这个问题。

26、在2.3.4节中,描述了一种有高优先级进程H和低优先级进程L的情况,导致了H陷入死循环。若采用轮转调度算法而不是优先级调度算法,还会发生这样问题吗?请给予讨论。

答:在轮转调度算法下。L迟早会运行,最终它将会离开临界区。关键是,在优先级调度算法下,L永远不会运行;循环,它定期得到一个正常的时间片,所以有机会离开其临界区。

27、在使用线程的系统中,若使用用户级线程,是每个线程一个堆栈还是每个进程一个堆栈?如果使用内核级线程倩况又如何呢?请给予解释。

答:每个线程都是自己调用例程,因此它必须有其自己的堆栈以保存局部变量、返回地址等等。这一点用户级线程和内核级线程是一样的。

28、在开发计算机时,通常首先用一个程序模拟,一次运行一条指令,甚至多处理器也严格按此模拟。在类似于这种没有同时事件发生的情形下,会出现竞争条件吗?

答:是的。模拟计算机也可以是多道程序设计的。例如,在进程A运行时,它读取一些共享变量。然后发生了一个模拟时钟周期和进程B运行。它也读取相同的变量,然后对变量进行了加1操作。当进程A运行时,如果它也对变量进行了加1操作,就发生了竞争条件。

29、将生产者-消费者问题扩展成一个多生产者-多消费者的问题,生成(消费)者都写(读)一个共享的缓冲区,每个生产者消费者都在自己的线程中执行。图2-28中使用信号量的解法在这个系统中还可行吗?

是的,它会按原样运作。 在给定的时刻,只有一个生产者(消费者)可以向缓冲区添加(移除)一个项目。

30、答:该解决方案满足互斥,因为两个过程都不可能在其关键部分。 也就是说,当转为0时,P0可以执行其临界区,但不能执行P1。 同样,当转弯为1.但是,这假定P0必须先运行。 如果P1产生某些东西并将其放入缓冲区,那么当P0可以进入其临界区时,它会发现缓冲区为空并阻塞。 而且,该解决方案需要严格交替两个过程,这是不希望的。

31、一个可以屏蔽中断的操作系统如何实现信号量?

要执行信号量操作,操作系统首先禁用中断。 然后它读取信号量的值。 如果它正在执行down并且信号量等于零,则它将调用进程放在与信号量关联的阻塞进程列表中。 如果它正在执行,它必须检查信号量是否阻止任何进程。 如果阻止了一个或多个进程,则会从阻塞进程列表中删除其中一个进程并使其可运行。 完成所有这些操作后,可以再次启用中断。

32、请说明仅通过二元信号量和普通机器指令如何实现计数信号量(即可以保持一个任意值得信号量)

将每个计数信号量与2个二值信号量联合:M用于互斥;S用于阻塞。另外,每个计数信号量都组合一个用于保存up次数减去down次数的计数器,以及在该信号量上阻塞的进程列表。为了实现down操作,进程首先通过对M执行down操作,以获得对信号量、计数器以及列表的独占访问权。然后,将计数器减 1。如果大于等于0, 只需对M执行up操作并退出即可。如果M为负数,就将该进程放入阻塞进程列表中。接着,对M执行up操作,对S执行down操作来阻塞该进程。为了实现up操作,首先对M执行down操作以获得互斥,然后将计数器加1。如果计数器大于0, 则没有进程阻塞,就只需对M执行up操作。不过, 如果计数器小于等于0, 则必须从列表中移出某些进程。最后,按次序对B和M执行up操作。

33、如果一个系统只有两个进程,可以使用一个屏障来同步这两个进程吗?为什么?

答:如果程序操作按阶段执行,直到两个进程都完成当前阶段才能进入下一阶段,这时就应该使用屏障。

34、如果线程在内核中实现,可以使用内核信号量对同一个进程中的两个线程进行同步吗?如果线程在用户空间实现呢?假设在其他进程中没有线程必须访问该信号量。请讨论你的答案。

答:对于内核线程,线程可以在信号量上阻塞,而内核可以运行该进程中的其它线程。因而,使用信号量没有问题。而对于用户级线程,当某个线程在信号量上阻塞时,内核将认为整个进程都被阻塞,而且不再执行它。因此,进程失败。

35、管程内的同步机制使用条件变量和两个特殊操作wait和signal,一种更通用的同步形式是只用一条原语waituntil,它以任意的布尔谓词作为参数。例如

waituntilx < 0 or y + z < n

这样就不再需要signal原语。很显然这一方式比Hoare或Brinch Hansen方案更通用,但它从未被采用过。为什么?提示:请考虑其实现。

答:其实现的代价很高。 每次在某些等待变化的进程的谓词中出现的任何变量, runtime系统都必须重新计算该谓词,以判断该进程是否能够被解锁。而对于 Hoare和Brinch Hansen管程,则只需signal原语即可唤醒进程。

36、一个快餐店有四类雇员:(1) 领班,接收顿客点的菜单;(2)厨师,准备饭菜;(3)打包工,将饭菜装在袋子里;(4) 收银员,将食品袋交给顾客并收钱。每个雇员可被看作一个进行通信的顺序进程。它们采用的进程间通信方式是什么?请将这个模型与UNIX中进程联系起来。

答:雇员之间通过消息传递进行通信:在该例中,消息为订单、食物和袋子。在UNIX中,该4个进程通过管道连接。

37、假设有一个使用信箱的消息传递系统,当向满信箱发消息或从空信箱收消息时,进程都不会阻塞,相反,会得到一个错误代码。进程响应错误代码的处理方式为一遍一遍地重试,直到成功为止。这种方式会导致竞争条件吗?

答:它不会导致竞争条件(不会丢失任何东西),不过它是完全的忙等待。

38、CDC 6600计算机使用一种称作处理器共享的有趣的轮转调度算法,它可以同时处理多达10个I/O进程。每条指令结束后都进行进程切换,这样进程1执行指令1,进程2执行指令2,以此类推。进程切换由特殊硬件完成,所以没有开销。如果在没有竞争的条件下一个进程需要T秒钟完成,那么当有n个进程共享处理器时完成一个进程需要多长时间?

答:它需要nT sec。

【【】】39、考虑以下C代码:

void main() {
	fork();
	fork();
	exit();
}

程序执行时创建了多少子进程?

创建了三个流程。 在初始进程分叉之后,有两个进程在运行,即父进程和子进程。 然后他们每个人分叉,创建两个额外的过程。 然后所有进程退出。

39、答:创建了三个进程。 在初始进程分叉之后,有两个进程运行,父进程和子进程。 然后他们每个人都分叉,创造了两个额外的过程。 然后所有进程退出。

40、Round-robin调度算法一般需要维护一个就绪进程列表,每个进程在列表中只出现一次。如果某个进程在列表中出现两次会发生什么情况?什么情况下允许多次出现?

如果进程在列表中多次出现,则每个循环将获得多个量子。 这种方法可用于为更重要的进程提供更大的CPU份额。 但是当进程阻塞时,最好从可运行进程列表中删除所有条目。

41、是否可以通过分析源代码来确定进程是CPU密集型的还是I/O密集型的?如何能在运行时刻进行此项决定?

答:在简单的情况下是有可能通过看源代码来判断是否为 I/O 绑定的。例如,程序开始时,将其所有输入文件读入到缓冲器中,这种程序通常不是 I/O 绑定的;但是,对不同文件进行增量地读写(诸如编译程序)的问题很有可能是I/O绑定的。如果操作系统提供诸如 UNIX ps的命令,就可以得知被程序使用的CPU 时间的量,你能把这个时间量与整个的时间比较以判断。当然,最有意义就是你是系统中唯一的用户。

42、请说明在Round-robin调度算法中时间片长度和上下文切换时间是怎么互相影响的。

43、对某系统进行监测后表明,当阻塞在I/O之前时,平均每个进程运行时间为T。一次进程切换需要的时间为S,这里S实际上就是开销。对于采用时间片长度为Q的轮转调度,请给出以下各种情况中CPU利用率的计算公式:

a) Q = ∞

b) Q > T

c) S < Q <T

d) Q = S

e) Q趋近于0

答:CPU的效率就是有用的CPU时间除以整个的CPU时间。当Q > T时,基本的周期就是进程运行T,然后进程切换S。因此,(a)和(b)的效率都是T/(T+S)。当时间片比T短时,每运行一次T就要求T/Q次进程切换,浪费时间为ST/Q。因此,其效率为

T/(T+ST/Q)

也就是下降到 Q/(Q+S),这就是(c)的答案。至于(d),只需以S替代Q,就可以计算出其效率为50%。最后,(e)的效率趋近于0。

44、有5个待运行作业,估计它们的运行时N分別是9, 6, 3, 5和X。采用哪种次序运行这些作业将得到最短的平均响应时间?(答案将依赖于X。)

答:最短作业优先可以使得平均响应时间最短。

0 < X ≤ 3: X, 3, 5, 6, 9.

3 < X ≤ 5: 3, X, 5, 6, 9.

5 < X ≤ 6: 3, 5, X, 6, 9.

6 < X ≤ 9: 3, 5, 6, X, 9.

X > 9: 3, 5,6, 9, X.

45、有5个批处理作业A到E,它们几乎同时到达一个计算中心。估计它们的运行时间分別为10,6,2,4和8分钟。其优先级(由外部设定)分别为3,5,2,1和4,其中5为最高优先级。对于下列每种调度算法,计算其平均进程周转时间,可忽略进程切换的开销。

a) 轮转法。

b) 优先级调度。

c) 先来先服务(按照10,6,2,4,8次序运行)。

d) 最短作业优先。

对a),假设系统具有多道程序处理能力,每个作业均公平共享CPU时间,对b)到d) ,假设任一时刻只有一个作业运行,直到结束。所有的作业都完全是CPU密集型作业。

答:对于时间片轮转,在头10分钟里,每个作业获得1/5的CPU时间。在第10 分钟时,C结束。在接下来的8分钟里,每个作业获得 1/4 的CPU时间,然后D完成,然后,在接下来的6分钟内,余下的3个作业各获得1/3的CPU时间,直到B结束,以此类推。因此,5个作业的完成时间分别为是10, 18, 24, 28和30, 平均为22分钟。对于优先级调度,5最先运行,6分钟完成。其它作业分别在第14, 24, 26和30分钟完成,平均为20分钟。如果作业按A->E的次序执行,则分别在第10,16, 18, 22和30分钟完成,因此,平均为19.2分钟。最后,最短作业优先调度的完成时间分别为第2, 6, 12, 20和30分钟,平均为14分钟。

46、运行在CTSS上的一个进程需要30个时间片完成。该进程必须被调入多少次,包括第一次(在该进程运行之前)?

答:第一次得到 1 个时间片。随后获得 2, 4, 8 和 15 个时间片,因此必须经过 5 次交换。

47、一个实时系统有2个周期为5ms的点化任务,每次任务的CPU时间是1ms, 还有一个周期为33ms的视频流,每次任务的CPU时间是11ms.这个系统是可调度的吗?

每个语音呼叫需要200个1毫秒或200毫秒的样本。 它们一起使用400毫秒的CPU时间。 视频需要11毫秒33 1/3次/秒,总共约367毫秒。 总和是每秒767毫秒的实时时间,因此系统是可调度的。

48、在上一题中,如果再加入一个视频流,系统还是可调度的吗?

另一个视频流每秒消耗367毫秒的时间,每秒实时总共1134毫秒,因此系统不可调度。

49、用a = 1/2的老化算法用来预测运行时间。先前的四次运行,从最老的一个到最近的一个,其运行时间分别是40ms,20ms,40ms和15ms。下一次的预测时间是多少?

答:预测值的顺序为40,30,35,所以下一次是25。(把前两个数据加一起,除以2,然后把结果和下一个数据加一起,除以2。)

50、一个软实时系统有4个周期时间,其周期分别为50ms,100ms,200ms和250ms。假设这4个事件分别需要35ms,20ms,10ms和x ms的CPU时间。保持系统可调度的最大x值是多少?

答:所使用的 CPU 的片断为 35/50 + 20/100 + 10/200 + x/250。为了使得进程可调度,必须是总和小于因此,x必须小于12.5ms。

51、在哲学家就餐问题中使用如下规则:编号为偶数的哲学家先拿他左边的叉子,再拿他右边的叉子;编号为奇数的哲学家先拿他右边的叉子再拿他左边的叉子。这条规则能否避免死锁?

是。 总会有至少一个免费的叉子和至少一个可以同时获得两个叉子的哲学家。 因此,不会有僵局。 您可以尝试N = 2,N = 3和N = 4,然后进行推广。

52、一个实时系统需要处理两个语音通信,每个运行5ms,然后每次突发消耗1ms CPU时间,加上25帧/秒的一个视频,每一帧需要20ms的CPU时间。这个系统是可调度的吗?

答:每个语音通信运行200次/秒,每次突发消耗1毫秒,所以每个语音通信需要200毫秒/秒或两个语音通信需要400毫秒/秒。视频运行25次/秒,每次使用了20毫秒的时间,总共为500毫秒/秒。它们一起消耗900毫秒/秒,所以还有时间剩余,系统是可调度的。

53、考虑一个系统,在这个系统中为了内核线程调度希望将策略和机制分离。请提出一个实现此目标的手段。

答:内核可以通过任何方式调度进程,但对于每个进程,严格按照进程的优先级顺序执行。通过让用户进程设置自己的优先级,让用户控制策略,而内核处理机制。

54、在哲学家就餐问题的解法 (图2-46)中,为什么在过程 take_forks中将状态变量置为HUNGRY?

答:如果某个哲学家阻塞,其邻居稍后能够在test中检测其状态,发现他已经饥饿,当叉子可用时,就可以唤醒他了。

55、考虑图2-47中的过程pm_forks,假设变量state[i]在对test的两次调用之后而不是之前被置为THINKING,这个改动会对解法有什么影响?

答:该变化将意味着在哲学家停止进餐后,他的邻居都不能接着被选择。事实上,他们永远不会被选择。假设哲学家2完成了进餐,他将为哲学家1和3运行test,而两者都不会被启动,即使他们两个都饿了而且两个叉子都是可用的。类似的,如果哲学家4完成进餐,哲学家3也不会被启动。他将无法启动。

56、按照哪一类进程何时开始,读者-写者问题可以有若干种方式求解。请详细描述该问题的三种变体,每一种变体偏好(或不偏好)某一类进程。对每种变体,请指出当一个读者或写者访问数据库时会发生什么,以及当一个进程结束对数据库的访问后又会发生什么?

答:变种1:读者优先。当读者活跃时,写者都无法启动。当一个新的读者出现时,它可以立即开始除非当前有写者是活跃的。当写者完成时,如果有读者在等待,他们全都启动,无论是否有写者存在。

变种2:写者优先。当有写者等待时,读者都不会开始。当最后活跃的进程结束,如果有作者,就启动它;否则,所有读者(如果有)全部开始。

变种3:平衡的版本。当有读者是活跃的,新的读者可以立即开始。当写者完成时,新的写者优先,如果有写者等待的话。也就是说,一旦开始读,就一直读到没有读者为止。同样地,一旦开始作,所有挂起的写者都被允许运行。

57、请编写一个shell脚本,通过读取文件的最后一个数字,对之加1,然后再将该数字附在该文件上,从而生成顺序数文件。在后台和前台分別运行该脚本的一个实例,每个实例访问相同的文件。需要多长时间才出现竞争条件?临界区是什么?请修改该脚本以避免竞争(提示:使用In file file.lock锁住数据文件。)

答:一个可行的shell脚本应该如下:

if [ ! –f numbers ]; then echo 0 > numbers; fi
count=0
while (test $count != 200 )
do
	count=‘expr $count + 1’
	n=‘tail –1 numbers’
 	expr $n + 1 >>numbers
done

同时运行该脚本两次,通过后台启动它一次(使用)和再次在前台启动。然后检查文件编号。它可能开始看起来会像数字的有序列表,但在某一时刻,由于运行脚本的两个副本而创建的竞争条件,它就失去了它的规律。通过对脚本的每一个副本测试,并在进入关键区域之前设置一个锁,在离开关键区域时打开它,可以避免竞争。可以这样做:

if ln numbers numbers.lock
then
    n=‘tail –1 numbers’
    expr $n + 1 >>numbers
    rm numbers.lock
fi

此版本只是当文件无法访问时直接跳过,不同的解决方案可以让进程休眠,忙等待,或仅仅循环计数,使得操作成功。

58、假设有一个提供信号量的操作系统。请实现一个消息系统,编写发送和接收消息的过程。

答:略。

59、使用管程而不是信号量来解决哲学家就餐题。

答:略。

2019-09-26 11:16:46 qq_41783563 阅读数 319
  • 2020考研专业课《计算机操作系统原理》精讲视频课程

    计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统课程还是非常容易理解和掌握的,终在考研时取得到高分。

    67597 人正在学习 去看看 任铄

作者:许东明
邮件:leafsunshin@163.com
最近更新时间:2019/9/26
教材:计算机操作系统第四版

1.1操作系统的目标和作用

1.1.1操作系统的目标

  1. 方便性
  2. 有效性
  • 提高系统资源利用率
  • 提高系统吞吐量
  1. 可扩展性
  2. 开放性

1.1.2操作系统的作用

  1. OS作为用户与计算机硬件系统之间的接口
    • 命令方式
    • 系统调用方式
    • 图标–窗口方式

  1. OS作为计算机系统资源的管理者
  2. OS实现对计算机资源的抽象

在这里插入图片描述

1.1.3推动操作系统发展的主要动力

  1. 不断提高计算机资源利用率
  2. 方便用户
  3. 器件的不断更新换代
  4. 计算机体系结构的不断发展
  5. 不断提出新的应用需求

1.2操作系统的发展过程

1.2.1未配置操作系统的计算机系统

  1. 人工操作方式

    • 用户独占全机
    • CPU等待人工操作
    • 严重降低了计算机资源的利用率
  2. 脱机输入/输出(Off–Line I/O)方式

    • 减少了CPU的空闲时间
    • 提高了I/O速度
    • 效率仍然不理想

1.2.2单道批处理系统

  1. 单道批处理系统的处理过程
    • 单道批处理系统是在解决人机矛盾和CPU与IO设备速度不匹配矛盾的过程中形成的
    • 换言之,批处理系统旨在提高系统资源的利用率和系统吞吐量
    • 但这种单道批处理系统仍然不能充分地利用系统资源,故现已很少使用。

在这里插入图片描述

  1. 单道批处理系统的缺点
    • 系统中的资源得不到充分的利用

1.2.3多道批处理系统

  1. 多道程序设计的基本概念

  1. 多道批处理系统的优缺点

    • 资源利用率高
    • 系统吞吐量大
    • 平均周转时间长
    • 无交互能力
  2. 多道批处理系统需要解决的问题

    • 处理机争用问题
    • 内存分配和保护问题
    • I/O设备分配问题
    • 文件的组织和管理问题
    • 作业管理问题
    • 用户和系统的接口问题

1.2.4分时系统(Time Sharing System)

  1. 分时系统的引入

    • 人-机交互
    • 共享主机
  2. 分时系统实现中的关键问题

    • 及时接收
    • 及时处理
      • 作业进入内村
      • 采用轮转运行方式
  3. 分时系统的特征

    • 多路性
    • 独立性
    • 交互性
    • 及时性

1.2.5实时系统(Real Time System)

  1. 实时系统的类型

    • 工业(武器)控制系统
    • 信息查询系统
    • 多媒体系统
    • 嵌入式系统
  2. 实时任务的类型

    • 周期性实时任务和非周期性实时任务
    • 硬实时任务和软实时任务
  3. 实时系统与分时系统特征的比较

    • 多路性
    • 独立性
    • 及时性
    • 交互性
    • 可靠性

1.2.6微机操作系统的发展

  1. 单用户单任务操作系统

    • CP/M
    • MS-DOS
  2. 单用户多任务操作系统

    • Windows
  3. 多用户多任务操作系统

    • Solaris OS
    • Linux OS

1.3操作系统的基本特性

1.3.1并发(Concurrence)

  1. 区别并行和并发
    • 并行性是指两个或多个事件在同一时刻发生→宏观并行,微观并行
    • 并发性是指两个或多个事件在同一时间间隔内发生→宏观并行,微观串行
    • 并发是进程宏观一起运行,微观上交替运行,而并行是指同时运行
  2. 引入进程
    • 进程是指在系统中能独立运行并作为资源分配的基本单位,它是由一组机器指令,数据和堆栈等组成的,是一个能独立运行的活动实体

1.3.2共享(Sharing)

OS环境下的资源共享或称为资源复用,是指系统中的资源可供内存中多个并发执行的进程共同使用

  1. 互斥共享方式
    • 当进程A要访问某资源时,必须先提出请求。若此时该资源空闲,系统便可将之分配给请求进程A使用。此后若再有其它进程也要访问该资源,只要A未用完就必须等待。仅当A进程访问完并释放系统资源后,才允许另一进程对该资源进行访问。
    • 这种资源共享方式称为互斥式共享,把这种在一段时间内只允许一个进程访问的资源,称为临界资源(或独占资源)。
  2. 同时访问方式
    • 并发和共享是多用户(多任务)OS的两个最基本的特征。它们又是互为存在的条件
    • 允许在一段时间内由多个进程“同时”对它们进行访问

1.3.3虚拟(virtual)

  1. 时分复用技术
    (1)虚拟处理机技术。利用多道程序设计技术,为每道程序建立至少一个进程,让多道程序并发执行
    (2)虚拟设备技术。我们还可以利用虚拟设备技术,也通过分时复用的方法,将一台物理IO设备虚拟为多台逻辑上的IO设备,并允许每个用户占用一台逻辑上的IO设备
    • 多道程序技术(时分复用技术)是通过利用处理机的空闲时间运行其它程序,提高了处理机的利用率
  2. 空分复用技术
    • 它是指将一个频率范围比较宽的信道划分成多个频率范围较窄的信道(称为频带),其中的任何一个频带都仅供一对用户通话
    • 空分复用技术则是利用存储器的空闲空间分区域存放和运行其它的多道程序,以此来提高内存的利用率

1.3.4异步(asynchronism)

  • 在多道程序环境下,系统允许多个进程并发执行。在单处理机环境下,由于系统中只有一台处理机,因而每次只允许一个进程执行,其余进程只能等待

1.4操作系统的主要功能

1.4.1处理机管理功能

处理机管理的主要功能有:
(1)创建和撤消进程
(2)对诸进程的运行进行协调
(3)实现进程之间的信息交换
(4)以及按照一定的算法把处理机分配给进程

  1. 进程控制
  2. 进程同步
    • 进程互斥方式
    • 进程同步方式(协同)
  3. 进程通信
  4. 调度
    • 作业调度
    • 进程调度

1.4.2存储器管理功能

存储器管理的主要任务:
(1)为多道程序的运行提供良好的环境
(2)提高存储器的利用率,方便用户使用,并能从逻辑上扩充内存。

  1. 内存分配
    • 主要任务:
      • 为每道程序分配内存空间,使它们“各得其所”
      • 提高存储器的利用率,尽量减少不可用的内存空间(碎片)
      • 允许正在运行的程序申请附加的内存空间,以适应程序和数据动态增长的需要
    • 静态分配
    • 动态分配
  2. 内存保护
    • 确保每道用户程序都仅在自己的内存空间内运行,彼此互不干扰。
    • 绝不允许用户程序访问操作系统的程序和数据,也不允许用户程序转移到非共享的其它用户程序中去执行。
  3. 地址映射
  4. 内存扩充
    • 借助虚拟存储技术
    • 功能:
      • 请求调入功能
      • 置换功能

1.4.3设备管理功能

设备管理的主要任务如下:
(1)完成用户进程提出的IO请求,为用户进程分配所需的I/O设备,并完成指定的I/O操作。
(2)提高CPU和IO设备的利用率,提高IO速度,方便用户使用IO设备

  1. 缓冲管理
    • 如果在IO设备和CPU之间引入缓冲,则可有效地缓和CPU和IO设备速度不匹配的矛盾,提高CPU的利用率,进而提高系统吞吐量。
    • 还可通过增加缓冲区容量的方法来改善系统的性能。
    • 最常见的缓冲区机制有:
      • 单缓冲机制
      • 能实现双向同时传送数据的双缓冲机制
      • 能供多个设备同时使用的公用缓冲池机制。
      • 上述这些缓冲区都由OS缓冲管理机制将它们管理起来。
  2. 设备分配
  3. 设备处理
    • 设备处理程序又称设备驱动程序

1.4.4文件管理功能

文件管理的主要任务是对用户文件和系统文件进行管理以方便用户使用,并保证文件的安全性。

  1. 文件存储空间的管理
    • 其主要任务是:
      • 为每个文件分配必要的外存空间
      • 提高外存的利用率
      • 进而提高文件系统的存、取速度
  2. 目录管理
  3. 文件的读写管理和保护

1.4.5操作系统与用户之间的接口

  1. 用户接口
    • 联机用户接口
    • 脱机用户接口
    • 图形用户接口
  2. 程序接口

1.4.6现代操作系统的新功能

  1. 系统安全
    • 认证技术
    • 密码技术
    • 访问控制技术
    • 反病毒技术
  2. 网络的功能和服务
    • 网络通信
    • 资源管理
    • 应用互操作
  3. 支持多媒体
    • 接纳控制功能
    • 实时调度
    • 多媒体文件的存储

1.5OS结构设计

1.5.1传统操作系统结构

  1. 无结构操作系统

  2. 模块化OS
    (1)模块化程序设计技术的基本概念

    (2)模块独立性

  • 在模块-接口法中,关键问题是模块的划分和规定好模块之间的接口。
  • 如果我们在划分模块时将模块划分得太小,虽然可以降低模块本身的复杂性,但会引起模块之间的联系过多,从而会造成系统比较混乱;
  • 如果将模块划分得过大,又会增加模块内部的复杂性,使内部的联系增加,因此在划分模块时,应在两者间进行权衡。
  • 另外,在划分模块时,必须充分注意模块的独立性问题,因为模块独立性越高,各模块间的交互就越少,系统的结构也就越清晰
    (1)内聚性,指模块内部各部分间联系的紧密程度。内聚性越高,模块独立性越强。
    (2)耦合度,指模块间相互联系和相互影响的程度。显然,耦合度越低,模块独立性越好。

(3)模块接口法的优缺点

    利用模块-接口法开发的OS,较之无结构OS具有以下明显的优点:
    (1)提高OS设计的正确性、可理解性和可维护性。
    (2)增强OS的可适应性。
    (3)加速OS的开发过程。
    模块化结构设计仍存在下述问题:
    (1)在OS设计时,对各模块间的接口规定很难满足在模块设计完成后对接口的实际需求。
    (2)在OS设计阶段,设计者必须做出一系列的决定(决策),每一个决定必须建立在上一个基础上
  1. 分层式结构OS
    (1)分层式结构的基本概念

     自底向上的分层设计的基本原则是:每一步设计都建立在可靠的基础上。为此规定,每一层仅能使用其底层所提供的功能和服务,这样可使系统的调试和验证都变得更容易
    

    (2)分层结构的优缺点

     分层结构的主要优点有:
     (1)易保证系统的正确性。自下而上的设计方式使所有设计中的决定都是有序的,或者说是建立在较为可靠的基础上的,这样比较容易保证整个系统的正确性。
     (2)易扩充和易维护性。在系统中增加、修改或替换一个层次中的模块或整个层次时,只要不改变相应层次间的接口,就不会影响其他层次,这必将使系统维护和扩充变得更加容易。
     分层结构的主要缺点:
     (1)系统效率降低。
     (2)由于层次结构是分层单向依赖的,必须在每层之间都建立层次间的通信机制,OS每执行一个功能,通常要自上而下地穿越多个层次,这无疑会增加系统的通信开销,从而导致系统效率的降低。        
    

1.5.2客户/服务器模式(Client/Server Model)

  1. 客户/服务器模式的由来、组成和类型

    • 客户服务器系统主要由三部分组成。
      • 客户机
      • 服务器
      • 网络系统
  2. 客户/服务器之间的交互

     (1)客户发送请求消息
     —当客户机上的用户要请求服务器进行应用处理时,应输入相应的命令和有关参数。由客户机上的发送进程先把这些信息装配成请求消息,然后把它发往服务器:客户机上的接收进程则等待接收从服务器发回来的响应消息
     (2)服务器接收消息
     —服务器中的接收进程平时处于等待状态,一旦有客户机发来请求,接收进程就被激活,根据请求信息的内容,将之提供给服务器上的相应软件进行处理。
     (3)服务器回送消息
     —服务器的软件根据请求进行处理,在完成指定的处理后,把处理结果装配成一个响应消息,由服务器中的发送进程将之发往客户机。
     (4)客户机接收消息
     —客户机中的接收进程把收到的响应消息转交给客户机软件,再由后者做出适当处理后提交给发送该请求的客户。
    
  3. 客户/服务器模式的优点

    • 数据的分布处理和存储
    • 便于集中管理
    • 灵活性和可扩充性
    • 易于改编应用软件
  4. 基本客户/服务器模式的不足之处

    • 是存在着不可靠性和瓶颈问题,在系统仅有一个服务器时,一旦服务器故障,将导致整个网络瘫痪。
    • 当服务器在重负荷下工作时,会因忙不过来而显著地延长对用户请求的响应时间,如果在网络中配置多个服务器,并采取相应的安全措施,则这种不足可加以改善。

1.5.3 面向对象的程序设计(Object-Orientated Programming)

  1. 面向对象技术的基本概念

    • 对象,是指在现实世界中具有相同属性、服从相同规则的一系列事物(事物可以是一个物理实体、一个概念或一个软件模块等)的抽象,而把其中的具体事物称为对象的实例

    • 如果在OS中的各类实体如进程、线程、消息、存储器和文件等都使用了对象这一概念,相应地,便有了进程对象、线程对象、消息对象、存储器对象和文件对象等。

        (1)对象
        - 在面向对象的技术中,是利用被封装的数据结构(变量)和一组对它进行操作的过程(方法)来表示系统中的某个对象的,如图1-8所示。
        - 对象中的变量(数据)也称为属性,它可以是单个标量或一张表。
        - 面向对象中的方法是用于执行某种功能的过程,它可以改变对象的状态,更新对象中的某些数据值或作用于对象所要访问的外部资源。
        - 对象中的变量(数据)对外是隐蔽的,因而外界不能对它直接进行访问,必须通过该对象中的一组方法(操作函数)对它进行访问。
      

     (2)对象类
     - 在实践中,有许多对象可能表示的是同一类事物,每个对象具有自己的变量集合,而它们所具有的方法是相同的。
     - 如果为每一个相似的对象都定义一组变量和方法,显然是低效的,由此产生了“对象类”的概念,利用“对象类”来定义一组大体相似的对象。
     - 一个类同样定义了一组变量和针对该变量的一组方法,用它们来描述一组对象的共同属性和行为。
     - 类是在对象上的抽象,对象则是类的实例。
     - 对象类中所定义的变量在实例中均有具体的值。
     
     (3)继承
     - 在面向对象的技术中,可以根据已有类来定义一个新的类,新类被称为子类(B),原来的类被称为父类(A),见图1-10所示。继承是父类和子类之间共享变量和方法的机制
    

     (4)面向对象技术的优点
     - 通过“重用”提高产品质量和生产率。
     - 使系统具有更好的易修改性和易扩展性。
     - 更易于保证系统的“正确性”和“可靠性”
    

1.5.4微内核os结构

  1. 微内核操作系统的基本概念

    • 足够小的内核
      • 与硬件处理紧密相关的部分
      • 一些较基本的功能
      • 客户和服务器之间的通信
    • 基于客户/服务器模式

    在这里插入图片描述

    • 应用“机制与策略分离”原理
    • 采用面向对象技术
  2. 微内核的基本功能

    • 进程(线程)管理
    • 低级存储器管理
    • 中断和陷入处理
  3. 微内核操作系统的优点

    • 提高了系统的可扩展性
    • 增强了系统的可靠性
    • 可移植性强
    • 提供了对分布式系统的支持
    • 融入了面向对象技术
  4. 微内核操作系统存在的问题

    • 微内核操作系统的运行效率有所降低
    • 效率降低最主要的原因是,在完成一次客户对操作系统提出的服务请求时,需要利用消息实现多次交互和进行用户/内核模式与上下文的多次切换

为了改善运行效率,可以重新把一些常用的操作系统基本功能由服务器移入微内核中。这样可使客户对常用操作系统功能的请求所发生的用户/内核模式和上下文的切换的次数由四次或八次降为两次。但这又会使微内核的容量明显地增大,在小型接口定义和适应性方面的优点也有所下降,并提高了微内核的设计代价。

习题
1.设计现代OS的主要目标是什么?
答:(1)有效性	(2)方便性	(3)可扩充性   (4)开放性

2.的作用可表现在哪几个方面?
答:
(1)OS作为用户与计算机硬件系统之间的接口
(2)OS作为计算机系统资源的管理者
(3)OS实现了对计算机资源的抽象

3.为什么说操作系统实现了对计算机资源的抽象?
答: 
(1)OS 首先在裸机上覆盖一层I/O 设备管理软件,实现了对计算机硬件操作的第一层次抽象;
(2)在第一层软件上再覆盖文件管理软件,实现了对硬件资源操作的第二层次抽象。
(3)OS 通过在计算机硬件上安装多层系统软件,增强了系统功能,隐藏了对硬件操作的细节,由它们共同实现了对计算机资源的抽象。

4.试说明推动多道批处理系统形成和发展的主要动力是什么?
答:主要动力来源于四个方面的社会需求与技术发展:
(1)不断提高计算机资源的利用率;
(2)方便用户;
(3)器件的不断更新换代;
(4)计算机体系结构的不断发展。

5.何谓脱机和联机IO?
答:脱机I/O 是指事先将装有用户程序和数据的纸带或卡片装入纸带输入机或卡片机,在外围机的控制下, 把纸带或卡片上的数据或程序输入到磁带上。该方式下的输入输出由外围机控制完成,是在脱离主机的情况下进行的。而联机 I/O 方式是指程序和数据的输入输出都是在主机的直接控制下进行的。

6.试说明推动分时系统形成和发展的主要动力是什么?
答:推动分时系统形成和发展的主要动力是更好地满足用户的需要。主要表现在:CPU的分时使用缩短了作业的平均周转时间;人机交互能力使用户能直接控制自己的作业;主机的共享使多用户能同时使用同一台计算机,独立地处理自己的作业。

7.实现分时系统的关键问题是什么?应如何解决?
答:关键问题是当用户在自己的终端上键入命令时,系统应能及时接收并及时处理该命令,在用户能接受的时延内将结果返回给用户。解决方法: 针对及时接收问题,可以在系统中设置多路卡,使主机能同时接收用户从各个终端上输入的数据; 为每个终端配置缓冲区,	暂存用户键入的命令或数据。针对及时处理问题,应使所有的用户作业都直接进入内存,并且为每个作业分配一个时间片,允许作业只在自己的时间片内运行,这样在不长的时间内,能使每个作业都运行一次。

8.为什么要引入实时操作系统?
答:实时 操作系统 是指系统能及时响应外部事件的请求,在规定的时间内完成对该事件的处理,并控制所有实时任务协调一致地运行。引入实时	OS	是为了满足应用的需求,更好地满
足实时控制领域和实时信息处理领域的需要。

9.什么是硬实时任务和软实时任务?试举例说明。
答:硬实时任务是指系统必须满足任务对截止时间的要求,否则可能出现难以预测的结果。举例来说,运载火箭的控制等。
软实时任务是指它的截止时间并不严格,偶尔错过了任务的截止时间,对系统产生的影响不大。举例:网页内容的更新、火车售票系统。

10.试从交互性、及时性以及可靠性方面将分时系统与实时系统进行比较
答:
(1)及时性:实时信息处理系统对实时性的要求与分时系统类似,都是以人所能接受的等待时间来确定;	而实时控制系统的及时性,是以控制对象所要求的开始截止时间或完成截止时间来确定的,一般为秒级到毫秒级,甚至有的要低于100 微妙。
(2)交互性:实时信息处理系统具有交互性,但人与系统的交互仅限于访问系统中某些特定的专用服务程序。不像分时系统那样能向终端用户提供数据和资源共享等服务。
(3)可靠性:分时系统也要求系统可靠,但相比之下,实时系统则要求系统具有高度的可靠性。 因为任何差错都可能带来巨大的经济损失,甚至是灾难性后果,所以在实时系统中,往往都采取了多级容错措施保障系统的安全性及数据的安全性。

11.OS有哪几大特征?其最基本的特征是什么?
答:并发性、共享性、虚拟性和异步性四个基本特征;最基本的特征是并发性。

12.在多道程序技术的OS环境下的资源共享与一般情况下的资源共享有何不同?对独占资源应采取何种共享方式?
答:一般情况下的资源共享只要通过适当的安排,用户之间并不会产生对资源的竞争。在0S环境下的资源共享是指系统中的资源可供内存中多个并发执行的进程共同使用。
解决的方法:1.互斥共享方式。2.同时访问方式

13.什么是时分复用技术?举例说明它能提高资源利用率的根本原因是什么
答:时分复用技术,将资源在不同的时间片内分配给各种进程使该资源被重复利用,从而提高资源的利用率。如果采用时分复用技术的虚拟处理机,能够在不同的时间片内处理多个用户的请求,从而使得用户感觉自己独占主机,而处理机在这期间内也被充分的利用。

14.是什么原因使操作系统具有异步性特征?
答:操作系统的异步性体现在三个方面:一是进程的异步性,进程以人们不可预知的速度向前推进。二是程序的不可再现性,即程序执行的结果有时是不确定的,即每个程序何时执行,执行顺序以及完成数据是不确定的。

15.处理机管理有哪些主要功能?其主要任务是什么?
答:处理机管理的主要功能是:进程管理、进程同步、进程通信和处理机调度进程管理:为作业创建进程,撤销已结束进程,控制进程在运行过程中的状态转换。步:为程)的运行进进程同步:为多个进程(含线程)的运行进行协进程通信:用来实现在相互合作的进程之间的信息交换。
处理机调度:
(1)作业调度。从后备队里按照一定的算法,选出若干个作业,为他们分配运行所需的资源(首选是分配内存)。
(2)进程调度:从进程的就绪队列中,按照一定算法选出一个进程,把处理机分配给它,并设置运行现场,使进程投入执行。

16.内存管理有哪些主要功能?其主要任务是什么?
答:内存管理的主要功能有:内存分配、内存保护、地址映射和内存扩充。内存保护:确保每道用户程序都只在自己的内存空间运行,彼此互不干扰地址映射:将地址空间的逻辑地址转换为内存空间与对应的物理地址,内存扩充:用于实现请求调用功能,置换功能等。

17.设备管理有哪些主要功能?其主要任务是什么?
答:
主要功能有:缓冲管理、设备分配和设备处理以及虚拟设备等。
主要任务:完成用户提出的10请求,为用户分配0设备;提高CPU和0设备的利用率;提高0速度;以及方便用户使用10设备。

18.文件管理有哪些主要功能?其主要任务是什么?
答:
文件管理主要功能:文件存储空间的管理、目录管理、文件的读写管理和保护。
文件管理的主要任务:管理用户文件和系统文件,方便用户使用,保证文件安全性。

19.试说明推动传统OS演变为现代OS的主要因素是什么?
答:系统安全、网络的功能和服务、支持多媒体。

20.什么是微内核OS?
答:足够小的内核;基于客户\服务器模式;应用机制与策略分离原理;采用面向对象技术;

21.微内核操作系统具有哪些优点?它为何能有这些优点?
答:
1.提高了系统的可扩展性;
2.增强了系统的可靠性;
3.可移植性;
4.易于改编应用软件

22.现代操作系统较之传统操作系统又增加了哪些功能和特征?
答:进程管理、低级存储器管理、中断和陷入处理

23.在微内核OS中,为什么要采用客户/服务器模式?
答:C\S有独特的优点:
1、数据的分布和存储;
2、便于集中管理;
3、灵活性和可扩充性;
4、易于改编应用软件。

24.在基于微内核结构的OS中,应用了哪些新技术?
答:在基于微内核的中采用了面向对象的程序设计技术。

25.何谓微内核技术?在微内核中通常提供了哪些功能?
答:把操作系统中更多的成分和功能放到更高的层次(即用户模式)中去运行而留下一个尽量小的内核,用它来完成操作系统最基本的核心功能,称这种技术为微内核技术,在微内核中通常提供了进程管理,低级存储器管理,中断和陷入处理等功能


没有更多推荐了,返回首页