本文共 16639 字，大约阅读时间需要 55 分钟。
目录
Day1
错选择
在单处理器系统中，如果同时存在有12个进程，则处于就绪队列中的进程数量最多为（）
A 1 B 9 C 10 D 11
正确答案：D
一个在运行，其余十一个都在就绪队列中
以下关于多线程的叙述错误的是：
A 线程同步的方法包括使用临界区，互斥量，信号量等 B 两个线程同时对简单类型全局变量进行写操作也需要互斥 C 实现可重入函数时，对自动变量也要用互斥量加以保护 D 可重入函数不可以调用不可重入函数
正确答案：C
可重入函数可认为是可以被中断的函数，自动变量定义的时候才被创建，函数返回时，系统回收空间，他是的是局部作用域变量，不需要互斥量。可重入函数对全局变量才需要互斥量保护。
整数0x12345678，在采用bigendian中内存的排序序列是（ ）
A 12 34 56 78 B 78 56 34 12 C 87 65 43 21 D 21 43 65 87
正确答案：A
小端模式：（从低字节到高字节）
地位地址 0x78 0x56 0x34 0x12 高位地址大端模式：（从高字节到低字节）
地位地址 0x12 0x34 0x56 0x78 高位地址使用C语言将一个1G字节的字符数组从头到尾全部设置为字’A’，在一台典型的当代PC上，需要花费的CPU时间的数量级最接近（）
A 0.001秒 B 1秒 C 100秒 D 2小时
正确答案： B
执行1条语句约1ns即10的-9次方秒，1G=1024M=1024*1024k=1024*1024*1024byte，每次赋值1byte都要执行一次语句，故至少花费1024*1024*1024*10^-9=1.073741824s
对于普通的计算机，对以下事件的平均耗时从小到大排序为____：
A.读取1KB内存数据 B.从硬盘连续读取1KB数据 C.读取一次L2缓存 D.一次磁盘寻道 A C,A,D,B B C,D,A,B C D,C,A,B D D,A,C,B
正确答案： A
速度最快的当然是缓存，接着消耗时间最少的是内存，磁盘寻道时间，然后是硬盘连续读取时间。
分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数（ ）
A 成正比 B 成反比 C 无关 D 成固定值
正确答案：C
由于内存的大小是固定的，所以无论页面是大是小，可以进入内存的大小也是固定的，最多不超过内存的大小。实际上，分页的大小并不影响进入内存作业的数量。从宏观上看，进入内存的页面内容是没有变化的。 所以分页式虚拟存储管理系统中，页面的大小与可能产生的缺页中断次数关系不大。
关于子进程和父进程的说法，下面哪一个是正确的？（）
A 一个父进程可以创建若干个子进程，一个子进程可以从属于若干个父进程 B 父进程被撤销时，其所有子进程也被相应撤消 C 子进程被撤销时，其从属的父进程也被撤销 D 一个进程可以没有父进程或子进程
正确答案： D
一个子进程只能有一个父进程
1.孤儿进程
如果父进程先退出,子进程还没退出那么子进程将被 托孤给init进程,这是子进程的父进程就是init进程(1号进程). init进程没有父进程.2.僵尸进程
进程终止后进入僵死状态(zombie),等待告知父进程自己终止,后才能完全消失.但是如果一个进程已经终止了,但是其父进程还没有获取其状态,那么这个进程就称之为僵尸进程.僵尸进程还会消耗一定的系统资源,并且还保留一些概要信息供父进程查询子进程的状态可以提供父进程想要的信息.一旦父进程得到想要的信息,僵尸进程就会结束.关于线程和进程，下面说法正确的是（）
A 终止一个进程比终止一个线程花费的时间少 B 进程切换比同一进程内部的线程切换花费的时间少 C 线程提高了不同执行程序间的通信效率 D 进程和线程都是资源分配和调度的基本单位
正确答案：C
线程的切换要比进程切换花费的时间少，线程是系统调度的基本单位，进程是资源分配的基本单位，所以ABD都是错的。
进程调度时，下列进程状态的变化过程哪一项是不可能发生的？（）
A 阻塞挂起->阻塞 B 就绪挂起->就绪 C 就绪挂起->阻塞挂起 D 阻塞挂起->就绪挂起
正确答案：C
星际密码
import java.util.*;public class Main { public static String fid(int n) { if(n < 3) return change(n); int a = 1; int b = 2; int c = 0; for(int i = 2; i < n; i++) { c = a + b; a = b; b = c % 100000; } return change(c); } public static String change(int c) { String str = String.valueOf(c); int len = str.length(); StringBuilder res = new StringBuilder(); if(len < 5) { for(int i = 0; i < 4-len; i++) { res.append(0); } res.append(str); return res.toString();} for(int i = len-4; i < len; i++) { res.append(str.charAt(i)); } return res.toString(); } public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNext()) { int n = in.nextInt(); for(int i = 0; i < n; i++) { int num = in.nextInt(); System.out.print(fid(num)); } System.out.println(); } }} 数根
import java.util.*;public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNext()) { String str = in.nextLine(); System.out.println(gen(str)); } } public static String gen(String str) { if(str.length() == 1) return str; while(str.length() > 1){ str = pas(str); } return str; } public static String pas(String str) { int sum = 0; for (int i = 0; i < str.length(); i++) { char c = str.charAt(i); int tmp = c-'0'; sum += tmp; } String res = String.valueOf(sum); return res; }} Day2
错选择
在系统内存中设置磁盘缓冲区的主要目的是（）。
A 减少磁盘 I/O 次数 B 减少平均寻道时间 C 提高磁盘数据可靠性 D 实现设备无关性
正确答案：A
为了弥补cpu和io外设之间的速度差
下列选项中，会导致进程从执行态变为就绪态的事件是（）。
A 执行 P(wait)操作 B 申请内存失败 C 启动 I/O 设备 D 被高优先级进程抢占
正确答案： D
P操作表示进程请求某一资源，ABC都因为请求某一资源会进入阻塞态，而D只是被剥夺了处理机资源，进入就绪态，一旦得到处理机即可运行。
在现代操作系统中采用缓冲技术的主要目的是（）。
A 改善用户编程环境 B 提高CPU的处理速度 C 提高CPU和设备之间的并行程度 D 实现与设备无关性
正确答案： C
由于缓冲区(buffer)的存在，CPU 和设备不必等对方完全处理完，所以提高了并行程度。
进程和程序的一个本质区别是（）。
A 前者为动态的，后者为静态的 B 前者存储在内存，后者存储在外存 C 前者在一个文件中，后者在多个文件中 D 前者分时使用CPU,后者独占CPU
正确答案： A
进程为动态的，程序为静态的
进程是程序的动态执行表现，程序是静态的。一个进程的读磁区操作完成后，操作系统针对该进程必做的是 （）
A 修改进程状态为就绪态 B 降低进程优先级 C .进程分配用户内存空间 D 增加进程的时间片大小
正确答案： A
进程申请读磁盘操作的时候，因为要等待工/ 〇完成，将自身阻塞，进入阻塞态。当 I/ 〇完成之后，从阻塞进入就绪态
选择在最近的过去很久未访问的页面予以淘汰的算法称为（）。
A Opt. B LRU C MFU D LFU
正确答案： B
OPT：Optimal page replacement algorithm最佳页面替换算法。
LRU：Least Recently Used 近期最少使用算法。 MFU：Most Frequently Used最常使用页面置换算法 LFU：Least Frequently Used最近最不常使用算法。并发进程之间（）。
A 彼此无关 B 必须同步 C 必须互斥 D 可能需要同步或互斥
正确答案： D
进程之间存在着直接制约和间接制约两种制约关系：
其中直接制约（同步）是由于进程间的相互合作引起的，而间接制约（互斥）则是由于进程间共享临界资源而引起的。一次I/O操作的结束，有可能导致()。
A 一个进程由睡眠变就绪 B 几个进程由睡眠变就绪 C 一个进程由睡眠变运行 D 几个进程由睡眠变运行
正确答案： A
进程的三种基本状态：
（1） 就绪状态：进程已获得除CPU外的所有必要资源，只等待CPU时的状态。一个系统会将多个处于就绪状态的进程排成一个就绪队列。 （2） 执行状态：进程已获CPU，正在执行。单处理机系统中，处于执行状态的进程只一个；多处理机系统中，有多个处于执行状态的进程。 （3） 阻塞状态：正在执行的进程由于某种原因而暂时无法继续执行，便放弃处理机而处于暂停状态，即进程执行受阻。（这种状态又称等待状态或封锁状态）进程未获得i/o设备故处于阻塞状态，获得i/o设备 ，但未获得cpu资源，故处于就绪状态
一次I/O的结束有可能使等待io的进城得到资源，但会先转为就绪状态。不会直接进入运行状态变态跳台阶
public class Solution { public int jumpFloorII(int target) { if (target == 1) return 1; return 2 * jumpFloorII(target - 1); }} 快到碗里来
import java.util.*;public class Main { public static void main(String[] args){ Scanner in = new Scanner(System.in); while (in.hasNext()) { Double n = in.nextDouble(); Double r = in.nextDouble(); if(n < 2 * 3.14 * r) System.out.println("Yes"); else System.out.println("No"); } }} Day3
错选择
若一个用户进程通过read 系统调用读取一个磁盘文件中的数据，则下列关于此过程的叙述中，正确的是（ ）。
Ⅰ． 若该文件的数据不在内存中，则该进程进入睡眠等待状态 Ⅱ． 请求 read 系统调用会导致 CPU 从用户态切换到核心态 Ⅲ． read 系统调用的参数应包含文件的名称 A 仅Ⅰ、 Ⅱ B 仅Ⅰ、 Ⅲ C 仅Ⅱ、 Ⅲ D Ⅰ、 Ⅱ和Ⅲ
正确答案： A
- 对于Ⅰ，当所读文件的数据不在内存时，产生中断（缺页中断），原进程进入阻塞状态，直到所需数据从外存调入内存后，才将该进程唤醒。
- 对于Ⅱ，read系统调用通过陷入将CPU从用户态切换到核心态，从而获取操作系统提供的服务。
- 对于Ⅲ，要读一个文件首先要用open系统调用打开该文件。open中的参数包含文件的路径名与文件名，而read只需要使用open返回的文件描述符，并不使用文件名作为参数。read要求用户提供三个输入参数： ①文件描述符fd； ②buf缓冲区首址； ③传送的字节数n。 read的功能是试图从fd所指示的文件中读入n个字节的数据，并将它们送至由指针buf所指示的缓冲区中。
Linux文件权限一共10位长度，分成四段，第三段表示的内容是（）？
A 文件类型 B 文件所有者的权限 C 文件所有者所在组的权限 D 其他用户的权限
正确答案： C
例如 ：
drwxr-xr-x d :第一段，表示文件类型（文件？目录） rwx: 第二段，文件所有者权限 r-x:第三段，文件所有者所在组权限 r-x:第四段，其他用户权限关于读写锁的描述，以下正确的是（）
A 在任何时刻，获得锁权限的线程只有一个 B 读写锁可以同时存在读者和写者 C 读写锁在写加锁状态时，其他进行写操作线程不会阻塞，一直循环查询读写锁是否可用 D 读写锁在读加锁的状态下，可用进行读共享
正确答案： D
读写锁在写加锁状态时，其他进行写操作线程会阻塞. 写锁就是防止其他进程读或写. 读锁就是防止在读的时候有写进程进入
不用加减乘除做加法
public class Solution { public int Add(int num1,int num2) { while(num2 != 0) { int c = (num1 & num2) << 1; num1 = num1 ^ num2; num2 = c; } return num1; }} 三角形
import java.util.*;import java.math.BigInteger;public class Main{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while(sc.hasNext()){ BigInteger a=sc.nextBigInteger(); BigInteger b=sc.nextBigInteger(); BigInteger c=sc.nextBigInteger(); if(a.add(b).compareTo(c)>0 && a.add(c).compareTo(b)>0 && b.add(c).compareTo(a)>0) System.out.println("Yes"); else System.out.println("No"); } }} Day4
错选择
下列有关在一个处理器（processor）上跑两个线程（thread）的说法中，正确的是?
A 一个线程可以改变另一个线程的程序计数器（program counter） B 一个线程既不能读也不能写另一个线程的栈（stack） C 一个线程可以读写另一个线程的寄存器（register） D 以上都不对
正确答案： B
同一个进程中的两个线程，全局数据区和堆是相互可见的，栈并不是相互可见的。
程序计数器是用于存放下一条指令的地址的寄存器。如何减少换页错误？
A 进程倾向于占用CPU B 访问局部性（locality of reference）满足进程要求 C 进程倾向于占用I/O D 使用基于最短剩余时间（shortest remaining time）的调度机制
正确答案： B
减少换页错误的方法，即降低缺页中断率：
1、内存页框数。增加作业分得的内存块数。 2、页面大小。页面划分越大，中断率越低。 3、替换算法的优劣影响缺页中断次数 4、程序局部性。程序局部性好可减少缺页中断。通常所说的"存储保护"的基本含义是（）。
A 防止存储器硬件受损 B 防止程序在内存丢失 C 防止程序间相互越界访问 D 防止程序被人偷看
正确答案： C
"存储保护"的基本含义是防止程序间相互越界访问
下列进程调度算法中，（）可能会出现进程长期得不到调度的情况。
A 非强占式静态优先权法 B 强占式静态优先权法 C 时间片轮转调度算法 D 非强占式动态优先权法
正确答案： B
-
强占式：现行进程在运行过程中，如果有重要或紧迫的进程到达（其状态必须为就绪），则现运行进程将被迫放弃处理机 ，系统将处理机立刻分配给新到达的进程。
-
静态优先权 ：在创建进程时确定的，优先权在进程的整个运行期间保持不变。
-
动态优先权 ：在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能，该优先权会随着等待的时间增长而增长。
如果信号量的当前值为－4，则表示系统中在该信号量上有（）个进程等待。
A 4 B 3 C 5 D 0
正确答案： A
信号量为-m，就是有m个进程在等待，一共m+1个进程，还有一个已经进入临界区
基址寻址方式中，操作数的有效地址是____。
A 基址寄存器内容加上形式地址（位移量） B 程序计数器内容加上形式地址 C 变址寄存器内容加上形式地址 D 寄存器内容加上形式地址
正确答案： A
基址地址就是：基址寄存器的内容加上指令格式中的形式地址而形成的操作数的有效地址
若系统中只有用户级线程，则处理机调度单位是()。
A 线程 B 进程 C 程序 D 作业
正确答案： B
如果系统只有用户态线程，则线程对操作系统是不可见的，操作系统只能调度进程；
如果系统中有内核态线程，则操作系统可以按线程进行调度；若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。
A 顺序表 B 双链表 C 带头结点的双循环链表 D 单循环链表
正确答案： A
顺序表便于存取，不便于插入删除的原因是需要挪动大量数据，而在最后一项插入删除就没有了这样的顾虑…综合来看，顺序表好
奇数位上都是奇数或者偶数位上都是偶数
public class Solution { /** * 奇数位上都是奇数或者偶数位上都是偶数 * 输入：数组arr，长度大于2 * 将arr调整成奇数位上都是奇数或者偶数位上都是偶数 */ public void oddInOddEvenInEven(int[] arr) { if(arr==null || arr.length<2){ return; } int even=0; int odd=1; int end=arr.length-1; while(even <=end && odd<=end){ if(arr[end]%2==0){ swap(arr,end,even); even += 2; }else{ swap(arr,end,odd); odd += 2; } } } public void swap(int[]array,int i,int j){ int temp = array[i]; array[i] = array[j]; array[j] = temp; }} 猴子分桃
import java.util.*;public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNext()){ long n = in.nextInt(); if(n == 0) break; long a = (long)Math.pow(5, n); long b = (long)Math.pow(4, n); System.out.println((a-4)+" "+(b-4+n)); } }} Day5
错选择
在支持多线程的系统中，进程P创建的若干个线程不能共享的是（ ）。
A 进程 P 的代码段 B 进程 P 中打开的文件 C 进程 P 的全局变量 D 进程 P 中某线程的栈指针
正确答案： D
每个线程都有它自己的线程上下文.线程上下文包括：
线程ID,栈,栈指针,程序计数器,条件码和通用寄存器的值。
多个线程在进程敏感词享如下部分：
虚拟地址空间,只读代码块,读、写数据，堆，打开的文件集合。
进程的控制信息和描述信息存放在()。
A JCB B PCB C AFT D SFT
正确答案： B
JCB 作业控制块
PCB 进程控制块进程控制块(PCB)是系统为了管理进程设置的一个专门的数据结构。系统用它来记录进程的外部特征，描述进程的运动变化过程。同时，系统可以利用PCB来控制和管理进程，所以说，PCB（进程控制块）是系统感知进程存在的唯一标志。
当系统发生抖动（thrashing）时，可以采取的有效措施是（ ）。
Ⅰ．撤销部分进程 Ⅱ．增加磁盘交换区的容量 Ⅲ．提高用户进程的优先级 A 仅Ⅰ B 仅Ⅱ C 仅Ⅲ D 仅Ⅰ， Ⅱ
正确答案： A
发生“抖动”的根本原因是：
同时在系统中运行的进程太多 ，由此分配给每一个进程的物理块太少，不能满足进程正常运行的基本要求，致使每个进程在运行时，频繁地出现缺页，必须请求系统将所缺之页调入内 存。 太多的话， 最直接有效的方法当然是撤销部分进程。求正整数组的最小不可组成和
import java.util.*;public class Solution { /** * 正数数组中的最小不可组成和 * 输入：正数数组arr * 返回：正数数组中的最小不可组成和 */ public int getFirstUnFormedNum(int[] arr) { Arrays.sort(arr); List list = new ArrayList<>(); for (int value : arr) { list.add(value); } int sum = 0; for (int count = 0; count < arr.length; count++) { sum += arr[count]; int qu = sum; int start = 0; for (int i = count; i < arr.length-1; i++) { for (int j = i+1; j < arr.length; j++) { list.add(qu + arr[j]); } qu = qu - arr[start] + arr[i+1]; start++; } } list.sort(Integer::compareTo); int start = list.get(0); int end = list.get(list.size()-1); for(int k = start; k <= end; k++) { if(!list.contains(k)) { return k; } } return end+1; }} 有假币
import java.util.*;public class Solution { /** * 正数数组中的最小不可组成和 * 输入：正数数组arr * 返回：正数数组中的最小不可组成和 */ public int getFirstUnFormedNum(int[] arr) { int min = Integer.MAX_VALUE; int max = 0; for(int i = 0; i < arr.length; i++) { max += arr[i]; min = Math.min(min,arr[i]); } boolean[] form = new boolean[max+1]; form[0] = true; for(int i = 0; i < arr.length; i++) { for(int j = max; j >= arr[i]; j--) { form[j] = form[j - arr[i]] || form[j]; } } for(int i = min; i < form.length; i++) { if(!form[i]) { return i; } } return max+1; }} Day6
错选择
下列关于线程说法错误的是（）
A 耗时的操作使用线程，提高程序响应 B 耗内存的操作使用线程，提高内存利用率 C 多CPU的系统使用线程，提高CPU利用率 D 并行操作使用线程，如c/s架构中服务端程序为每个客户端请求创建一个线程来响应
正确答案： B
线程是为了节约时间，并不能解决内存
如果将固定块大小的文件系统中的块大小设置大一些，会造成（）。
A 更好的磁盘吞吐量和更差的磁盘空间利用率 B 更好的磁盘吞吐量和更好的磁盘空间利用率 C 更差的磁盘吞吐量和更好的磁盘空间利用率 D 更差的磁盘吞吐量和更差的磁盘空间利用率
正确答案： A
文件是按块存储的，如果块大小设置的大一些，读取的时候一次性读取的就更多，磁盘吞吐量提升，但是文件可能不能占满整个块，导致利用率下降。
在下列进程的四个特征中，最基本的特征是()。
A 并发性 B 动态性 C 独立性 D 异步性
正确答案： B
- 并发性：指多个进程实体同存于内存中，且在一段时间内同时运行。并发性是进程的重要特征，同时也成为操作系统的重要特征。
- 动态性：进程的实质是进程实体的一次执行过程，因此，动态性是进程最基本的特征。
- 独立性：进程实体是一个独立运行、独立分配资源和独立接受调度的基本单位。
- 异步性：指进程按各自独立的、不可预知的速度向前推进，或者说实体按异步方式运行。
下面有关Cache的说法哪一个是不正确的?
A 设置Cache的目的，是解决CPU和主存之间的速度匹配问题 B 设置Cache的理论基础，是程序访问的局部性原理 C Cache与主存统一编址，Cache的地址空间属于主存的一部分 D Cache的功能均由硬件实现，对程序员是透明的
正确答案： C
在所有非抢占CPU调度算法中，系统平均响应时间最优的是（ ）
A 实时调度算法 B 短任务优先算法 C 时间片轮转算法 D 先来先服务算法
正确答案： B
平均响应时间的话应该还是短作业优先。时间片轮转的话，短作业的响应时间变长了，然而长作业或中间的作业的响应时间也没变短多少，甚至不变短反而变长
假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
public static void main(String[]args)throws Exception { final Object obj = new Object(); Thread t1 = new Thread() { public void run() { synchronized (obj) { try { obj.wait(); System.out.println("Thread 1 wake up."); } catch (InterruptedException e) { } } } }; t1.start(); Thread.sleep(1000);//We assume thread 1 must start up within 1 sec. Thread t2 = new Thread() { public void run() { synchronized (obj) { obj.notifyAll(); System.out.println("Thread 2 sent notify."); } } }; t2.start(); } A Thread 1 wake up Thread 2 sent notify.
B Thread 2 sent notify. Thread 1 wake up C A、B皆有可能 D 程序无输出卡死
正确答案： B
t1 启动后执行 obj.wait() 时，进入阻塞状态，让出时间片并释放锁， 等待其他线程的唤醒。然后 t2 获取到 obj，并唤醒 t1，待 t2 执行完毕， 释放！！！锁！！！后，t1 再继续执行。
以下哪句的说法是正确的？
A 在页式存储管理中，用户应将自己的程序划分为若干个相等的页 B 所有的进程都挂起时，系统将陷入死锁 C 执行系统调用可以被中断 D 进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变
正确答案： C
A，页的划分是操作系统做的。
B，系统进入死锁必须满足4个条件：互斥、循环并等待、不剥夺、请求与保持；所有的进程都挂起，并不表示这些进程间有资源调用和循环等待的关系，有些进程定时器结束后可能自动唤醒。 D，有静态优先级调度。最难的问题
import java.util.*;public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNext()) { String str = in.nextLine(); char[] arr = str.toCharArray(); for(int i = 0; i < arr.length; i++) { arr[i] = change(arr[i]); System.out.print(arr[i]); } System.out.println(); } } public static char change(char c) { if(c >= 'F' && c <= 'Z') { c = (char)(c - 5); }else if(c == 'A') { c = 'V'; }else if(c == 'B') { c = 'W'; }else if(c == 'C') { c = 'X'; }else if(c == 'D') { c = 'Y'; }else if(c == 'E') { c = 'Z'; } return c; }} 因子个数
import java.util.*;public class Main { public static List list; public static void main(String[] args) { Scanner in = new Scanner(System.in); while(in.hasNext()) { int num = in.nextInt(); list = new ArrayList<>(); calc(num);// System.out.println(list); int len = list.size(); if(len < 2) { System.out.println(1); }else { System.out.println(len); } } } public static void calc(int num) { boolean inter = false; for(int i = 2; i*i <= num; i++) { if(num%i == 0) { inter = true; if(!list.contains(i) && !list.contains(num/i)) { calc(i); if(num/i != i) { calc(num/i); } } } } if(!inter) { list.add(num); } }} 转载地址：http://sixvi.baihongyu.com/