Java——Java选择题复习（1）（Java基础，进程，多线程，操作系统）

Bertha 。 2023-09-30 22:23 19阅读 0赞

> 1. 下面关于程序编译说法正确的是（）
> 
> A. java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
> 
> B. java编译出来的目标文件与具体操作系统有关
> 
> C. java在运行时才进行翻译指令
> 
> D. java编译出来的目标文件，可以运行在任意jvm上

**答案：C**

**题目解析：**

A. Java是半编译半解释型语言。

B. Java编译出来的目标文件是.class文件，与操作系统无关，面向JVM的二进制文件。

C. 编译：\*.java变成\*.class，运行：java JVM实际上此时会把class文件翻译成操作系统运行的机器码。

D. JVM也是有版本的，错误。

所以本题选择C选项。

> 2. 下面那些情况可以终止当前线程的运行？
> 
> A. 当一个优先级高的线程进入就绪状态时
> 
> B. 抛出一个异常时
> 
> C. 当该线程调用sleep()方法时
> 
> D. 当创建一个新线程时

**答案：B**

**题目解析：**

线程的终止，两种情况：

*  线程的任务执行完毕（正常终止）。
 *  线程执行过程中出现异常（异常终止）。

所以选择B。

> 3. 下面程序的运行结果：()
> 
>     public static void main(String args[]) {
>         Thread t=new Thread(){
>             public void run(){
>                 dianping();
>             }
>         };
>         t.run();
>         System.out.print("dazhong"); 
>     }
>     static void dianping(){
>         System.out.print("dianping");
>     }
> 
> A. dazhongdianping
> 
> B. dianpingdazhong
> 
> C. a和b都有可能
> 
> D. dianping循环输出，dazhong夹杂在中间

**答案：B**

**题目解析：**

线程的启动不能直接调用run()方法，要调用Thread类提供的start()方法，执行start()方法才会启动一个子线程。

直接调用run()方法，没有启动新线程，相当于调用普通方法而已，在本题中，先执行静态方法，再执行主方法，打印dianpingdazhong，选择B选项。

> 4. 下列说法正确的是（）
> 
> A. 形式参数可被字段修饰符修饰
> 
> B. 形式参数不可以是对象
> 
> C. 形式参数为方法被调用时真正被传递的参数
> 
> D. 形式参数可被视为local variable

**答案：D**

**题目解析：**

A：字段修饰符：类似public的权限修饰符。形参不可以被字段修饰符修饰。

B：形参可以是对象。

C：实参为方法被调用时真正被传递的参数

D：local variable的意思是局部变量，形参离开该方法后就会消失，是一种局部变量，正确。

所以本题选择D。

> 5. A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：
> 
> 1. A a0 = new A();
> 
> 2. A a1 = new B();
> 
> 3. A a2 = new C();
> 
> 以下哪个说法是正确的？
> 
> A. 第1行,第2行和第3行的声明都是正确的
> 
> B. 第1,2,3行都能通过编译，但第2,3行运行时出错
> 
> C. 第1,2行能通过编译，但第3行编译出错
> 
> D. 只有第1行能通过编译

**答案：A**

**题目解析：**

“A派生出子类B，B派生出子类C”——属于多层继承。

class A

class B extends A

class C extends B

1，2，3都属于向上转型，A选项正确。

> 6. 用命令方式运行以下代码的运行结果是（）
> 
>     public class f{
>         public static void main(String[] args){
>         String foo1 = args[1];
>         String foo2 = args[2];
>         String foo3 = args[3];
>         }
>     }
> 
> 命令: java f a b c
> 
> A. 程序编译错误
> 
> B. a b c
> 
> C. 程序运行错误
> 
> D. f

**答案：C**

**题目解析：**

命令格式：

编译命令：javac 源文件名称.java

运行命令：java 主类名称 要传递的参数（传递给main的args中）

所以本题 java f a b c表示把a,b,c传入args数组中，args = \{a,b,c\}，由此可见args的数组下标为0~2，所以代码中String foo3 = args\[3\];这一行访问了args\[3\]，会报出数组越界异常，是一种运行错误，所以选择C。

> 7. 下列说法正确的是
> 
> A. 在类方法中可用this来调用本类的类方法
> 
> B. 在类方法中调用本类的类方法可直接调用
> 
> C. 在类方法中只能调用本类的类方法
> 
> D. 在类方法中绝对不能调用实例方法

**答案：B**

**题目解析：**

A：this表示当前对象引用，不能调用静态域。

B：静态方法（类方法）没有对象，可以直接使用。

C，D：如果在类方法中创建了对象，仍然可以通过对象来调用实例方法。

所以选择B选项。

> 8. 以下哪项不属于java类加载过程？
> 
> A. 生成java.lang.Class对象
> 
> B. int类型对象成员变量赋予默认值
> 
> C. 执行static块代码
> 
> D. 类方法解析

**答案：B**

**题目解析：**

B：在对象产生时执行，在类加载之后，不属于类加载过程。

> 9. java中下面哪个能创建并启动线程（）
> 
>     public class MyRunnable implements Runnable {
>          public void run() {
>              //some code here
>          }
>     }
> 
> A. new Runnable(MyRunnable).start()
> 
> B. new Thread(MyRunnable).run()
> 
> C. new Thread(new MyRunnable()).start()
> 
> D. new MyRunnable().start()

**答案：C**

**题目解析：**

创建线程的两种方式：

1. 继承Thread类（包含使用匿名内部类创建）

2. 实现Runnable接口（包含使用匿名内部类创建，使用lambda表达式创建）

本题采取的是实现Runnable接口的方式，然后通过调用Thread类构造方法时将Runnable对象作为参数传入，**调用start方法**，启动创建新线程。

> 10. 如果希望监听TCP端口9000，服务器端应该怎样创建socket?
> 
> A. new Socket("localhost",9000);
> 
> B. new ServerSocket(9000);
> 
> C. new Socket(9000);
> 
> D. new ServerSocket("localhost",9000);

**答案：B**

**题目解析：**

服务器端使用ServerSocket(int port)——TCP端口（默认在本地指定端口号）

客户端使用Socket来连接服务器——Socket(IP,port)

所以本题选择B。

> 11.
> 
> int i=5;
> 
> int s=(i++)+(++i)+(i--)+(--i);
> 
> s=( )//s 的值是什么？
> 
> A. 28
> 
> B. 25
> 
> C. 21
> 
> D. 26
> 
> E. 24
> 
> F. 23

**答案：E**

**题目解析：**

i++(--)是先赋值再++(--)，++(--)i是先++(--)再赋值。

(i++)+(++i)+(i--)+(--i) = 5 + 7 + 7 + 5 = 24，选择E选项。

> 12. 下面不属于Object类中方法的是:
> 
> A. hashCode()
> 
> B. finally()
> 
> C. wait()
> 
> D. toString()

**答案：B**

**题目解析：**

没有finally()这个方法，finalize()是Object类的方法，用于线程的资源释放。

> 13. 以下代码在编译和运行过程中会出现什么情况
> 
>     public class TestDemo{
>         private int count;
>             public static void main(String[] args) {
>                 TestDemo test=new TestDemo(88);
>                 System.out.println(test.count);
>             }
>             TestDemo(int a) {
>             count=a;
>         }
>     }
> 
> A. 编译运行通过，输出结果是88
> 
> B. 编译时错误，count变量定义的是私有变量
> 
> C. 编译时错误，System.out.println方法被调用时test没有被初始化
> 
> D. 编译和执行时没有输出结果

**答案：A**

**题目解析：**

private在类内部可以使用，count是成员变量，通过对象访问。

可以通过编译运行，输出结果88，选择A。

> 14. 考虑下面这个简单的例子，让我们看看reflection是如何工作的。
> 
>     import java.lang.reflect.*;
>         public class DumpMethods{
>             public static void main(String[] args) {
>             try {
>                 Class c=Class.forName(args[0]);
>                 Method m[]=c.getDeclaredMethods();
>                 for (int i = 0; i < m.length; i++) {
>                     System.out.println(m[i].toString());
>                 }
>             } catch (Throwable e) {
>                 System.err.println(e);
>             }
>         }
>     }
> 
> 其中"c.getDeclaredMethods"的作用是:
> 
> A. 取得类的公有方法对象
> 
> B. 取得类的所有公有方法名称
> 
> C. 取得类的所有方法对象
> 
> D. 以上选项都不正确

**答案：D**

**题目解析：**

getMethods()和getDeclaredMethods()：

*  public Method\[\] getMethods()：获取该对象实现或继承的所有公共方法，包含继承的方法。
 *  public Method\[\] getDeclaredMethods()：获取该对象的所有声明的方法，包含该类中所有权限方法（public，private，default，protected）不包含从父类中继承的方法。

C：不包含从父类中继承的方法。

所以选择D选项。

> 15. 有如下4条语句：()
> 
>     Integer i01=59;
>     int i02=59;
>     Integer i03=Integer.valueOf(59);
>     Integer i04=new Integer(59);
> 
> 以下输出结果为false的是:
> 
> A. System.out.println(i01==i02);
> 
> B. System.out.println(i01==i03);
> 
> C. System.out.println(i03==i04);
> 
> D. System.out.println(i02==i04);

**答案：C**

**题目解析：**

i01：自动装箱

i03：装箱

i04：在堆上new了一个新的对象

A：比较时会将i01自动拆箱，还原为整型。

B：都是装箱操作，相同。

C：不相同，有new就有新空间，i03和i04都是对象，比较的是地址，i03和i04地址不等。

D：比较时会将i04自动拆箱，还原为整型。

> 16. 关于以下程序代码的说明正确的是()
> 
>     public class HasStatic {// 1
>         private static int x = 100;// 2
>         public static void main(String args[]) {// 3
>             HasStatic hsl = new HasStatic();// 4
>             hsl.x++;// 5
>             HasStatic hs2 = new HasStatic();// 6
>             hs2.x++;// 7
>             hsl = new HasStatic();// 8
>             hsl.x++;// 9
>             HasStatic.x--;// 10
>             System.out.println(" x=" + x);// 11
>         }
>     }
> 
> A. 程序通过编译，输出结果为:x=102
> 
> B. 程序通过编译，输出结果为:x=103
> 
> C. 10行不能通过编译.因为x星私有静态变量
> 
> D. 5行不能通过编译.因为引用了私有静态变量

**答案：A**

**题目解析：**

x是一个静态变量，可以直接通过类名称使用，也可以通过对象调用，所以C，D错误。

5：101，7：102，9：103，10：102，所以最后输出102，选择A选项。

> 17. 以下关于多线程的叙述中错误的是（）
> 
> A. 线程同步的方法包括使用临界区，互斥量，信号量等
> 
> B. 两个线程同时对简单类型全局变量进行写操作也需要互斥
> 
> C. 实现可重入函数时，对自动变量也要用互斥量加以保护
> 
> D. 可重入函数不可以调用不可重入函数

**答案：C**

**题目解析：**

A：实现线程同步的方法有很多，其中包括临界区，互斥量，事件，信号量四种方式。

*  临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。（临界区可以认为是操作共享资源的一段代码）。
 *  互斥量：为协调共同对一个共享资源的单独访问而设计的。
 *  信号量：为控制一个具有有限数量用户资源而设计。
 *  事件：用来通知线程有一些事件已发生，从而启动后继任务的开始。

C：

*  可重入函数：主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误。
 *  不可重入函数：由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。
 *  自动变量：局部作用域变量，定义的时候才被创建，函数返回时，系统回收空间，属于线程私有的。

自动变量是线程私有的，不存在共享，也就不存在线程安全的问题，不需要保护，C选项错误。

> 18. 使用C语言将一个1G字节的字符数组从头到尾全部设置为字’A’，在一台典型的当代PC上，需要花费的CPU时间的数量级最接近（）
> 
> A. 0.001秒
> 
> B. 1秒
> 
> C. 100秒
> 
> D. 2小时

**答案：B**

**题目解析：**

1GB = 1024MB

1MB = 1024KB

1KB = 1024B

1B = 8bits

所以1GB = 1，073，741，824B

执行一条语句约1ns，即1/1,000,000,000秒（10^-9）每次赋值1B都要执行一次语句，所以对于1G来说大约是1秒，即B选项。

> 19. 进程调度时，下列进程状态的变化过程哪一项是不可能发生的（）
> 
> A. 阻塞挂起->阻塞
> 
> B. 就绪挂起->就绪
> 
> C. 就绪挂起->阻塞挂起
> 
> D. 阻塞挂起->就绪挂起

**答案：C**

**题目解析：**

如图，就绪态不会转向阻塞态，所以选择C选项。

![d5bd688297eb428f94f0a352f4c889af.png][]

> 20. 处于运行状态的操作系统程序应放在（）
> 
> A. 寄存器中
> 
> B. 主存中
> 
> C. 辅存中

**答案：B**

**题目解析：**

A：寄存器容量有限，只是加载cpu执行代码行需要的数据（从主存加载到寄存器）。

B：处于运行状态的操作系统程序就是进程，进程应该运行在主存中，选择B选项。

C：进程挂起状态，进程就辅存中。

> 21. 进程和程序的一个本质区别是（）。
> 
> A. 前者为动态的，后者为静态的
> 
> B. 前者存储在内存，后者存储在外存
> 
> C. 前者在一个文件中，后者在多个文件中
> 
> D. 前者分时使用CPU,后者独占CPU

**答案：A**

**题目解析：**

进程：动态的，程序的一次执行过程。

程序：静态的，存放在磁盘的可执行文件。

A：进程和程序本质区别：动静态之分。

B：程序存储在外存，但是进程如果处于挂起状态，就会保存在外存。

C：不存在一个多个之说。

D：程序是静态的，不会占据CPU。

所以选择A选项。

> 22. 一个进程的读磁盘操作完成后，操作系统针对该进程必做的是 （）
> 
> A. 修改进程状态为就绪态
> 
> B. 降低进程优先级
> 
> C. .进程分配用户内存空间
> 
> D. 增加进程的时间片大小

**答案：A**

**题目解析：**

进程IO操作时是阻塞状态，操作完成后，操作系统将进程状态修改为就绪态，BCD选项都和IO操作无关，所以选择A选项。

> 23. 并发进程之间（）。
> 
> A. 彼此无关
> 
> B. 必须同步
> 
> C. 必须互斥
> 
> D. 可能需要同步或互斥

**答案：D**

**题目解析：**

**互斥**：是指散步在不同任务之间的若干程序片断，当某个任务运行其中一个程序片段时，其它任务就不能运行它们之中的任一程序片段，只能等到该任务运行完这个程序片段后才可以运行。最基本的场景就是：一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。

**同步**：是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。比如 A 任务的运行依赖于 B 任务产生的数据。

显然，**同步是一种更为复杂的互斥，而互斥是一种特殊的同步**。也就是说互斥是两个任务之间不可以同时运行，他们会相互排斥，必须等待一个线程运行完毕，另一个才能运行；同步也是不能同时运行，但是其必须要安照某种次序来运行相应的线程（也是一种互斥）。因此互斥具有唯一性和排它性，但互斥并不限制任务的运行顺序，即任务是无序的，而同步的任务之间则有顺序关系。

> 24. 若一个用户进程通过read 系统调用读取一个磁盘文件中的数据，则下列关于此过程的叙述中，正确的是（ ）。
> 
> Ⅰ． 若该文件的数据不在内存中，则该进程进入睡眠等待状态
> 
> Ⅱ． 请求 read 系统调用会导致 CPU 从用户态切换到核心态
> 
> Ⅲ． read 系统调用的参数应包含文件的名称
> 
> A. 仅Ⅰ、 Ⅱ
> 
> B. 仅Ⅰ、 Ⅲ
> 
> C. 仅Ⅱ、 Ⅲ
> 
> D. Ⅰ、 Ⅱ和Ⅲ

**答案：A**

**题目解析：**

read系统调用——>IO读取操作。

I：若文件的数据不在内存中，则进程进入睡眠模式的目的是等待内存堆磁盘上文件的映射，因为磁盘的读取比较慢，所以事先进入睡眠模式。

II：read是系统调用，所以CPU从用户态切换到核心态。

III：open系统调用应该包含文件的名称，read只是包含输入流。

所以I，II正确，选择A选项。

> 25. 进程阻塞的原因不包括（）
> 
> A. 时间片切换
> 
> B. 等待I/O
> 
> C. 进程sleep
> 
> D. 等待解锁

**答案：A**

**题目解析：**

A：

*  时间片之内——执行态。
 *  时间片用完——就绪态。

不存在阻塞态，选择A选项。

> 26. 在缺页处理过程中，操作系统执行的操作可能是（）
> 
> Ⅰ．修改页表
> 
> Ⅱ．磁盘 I/O
> 
> Ⅲ．分配页框
> 
> A. 仅Ⅰ、 Ⅱ
> 
> B. 仅Ⅱ
> 
> C. 仅Ⅲ
> 
> D. Ⅰ、 Ⅱ和Ⅲ

**答案：D**

**题目解析：**

**缺页**：缺页是引入了虚拟内存后的一个概念。操作系统启动后，在内存中维护着一个虚拟地址表，进程需要的虚拟地址在虚拟地址表中记录。一个程序被加载运行时，只是加载了很少的一部分到内存，另外一部分在需要时再从磁盘载入。被加载到内存的部分标识为“驻留”，而未被加载到内存的部分标为“未驻留”。操作系统根据需要读取虚拟地址表，如果读到虚拟地址表中记录的地址被标为“未驻留”，表示这部分地址记录的程序代码未被加载到内存，需要从磁盘读入，则这种情况就表示"缺页"。这个时候，操作系统触发一个“缺页”的硬件陷阱，系统从磁盘换入这部分未“驻留”的代码。

**页表**：页表是一种特殊的[数据结构][Link 1]，放在系统空间的页表区，存放逻辑页与物理页帧的对应关系。 每一个[进程][Link 2]都拥有一个自己的页表，[PCB][]表中有指针指向页表。

**页框（物理块）**：将内存空间分成一个个大小相等的分区（页框号或物理块号从0开始）。

I：如果某一页操作完了，要进行下一页操作，可能涉及到修改页表的操作。

II：页表如果需要修改一些数据，所需的数据在磁盘，也会涉及到磁盘I/O。

III：读取新的页表，就涉及到需要分配页框。

所以I，II，III都可能出现，选择D。

> 27. 下列选项中，降低进程优先级的合理时机是（）
> 
> A. 进程的时间片用完
> 
> B. 进程刚完成I/O，进入就绪列队
> 
> C. 进程持久处于就绪列队
> 
> D. 进程从就绪状态转为运行态

**答案：A**

**题目解析：**

A：时间片用完，进程还没有进入就绪队列，这时降低优先级，正好可以进入就绪队列。

B：已经进入就绪队列，没有A选项合理。

C：本来就得不到执行，再降低更无法执行。

D：已经运行，不会看优先级，不够合理。

所以选择A选项。

> 28. 下列有关在一个处理器（processor）上跑两个线程（thread）的说法中，正确的是?
> 
> A. 一个线程可以改变另一个线程的程序计数器（program counter）
> 
> B. 一个线程既不能读也不能写另一个线程的栈（stack）
> 
> C. 一个线程可以读写另一个线程的寄存器（register）
> 
> D. 以上都不对

**答案：B**

**题目解析：**

A：线程私有，无法改变。

B：栈是线程私有，看不到是正确的。

C：寄存器信息是线程私有的相关信息，错误。

选择B选项。

> 29. 通常所说的"存储保护"的基本含义是（）
> 
> A. 防止存储器硬件受损
> 
> B. 防止程序在内存丢失
> 
> C. 防止程序间相互越界访问
> 
> D. 防止程序被人偷看

**答案：C**

**题目解析：**

在采用虚拟存储技术的存储系统中，一个多任务的操作系统经常将多个不同的程序同时调入主存执行：

1. 首先需要保证这些程序间不会相互覆盖；

2. 一个程序不能访问其他程序的数据以及不是分配给他的主存区域。

3. 一个程序出错不会破坏其他用户程序和系统程序。

为了满足以上条件，采取一些限制方式保护主存中程序的技术被称为**存储保护**。存储区域保护主要是为了防止地址越界。

简单的说，存储保护就是对主存中的程序和数据进行保护。为了降低开销，在进行存储保护的时候，通常不会直接保护单个存储单元，而是以页或者段为单位进行保护。

A，B，D都不属于存储保护的范围，选择C选项。

> 30. 若系统中只有用户级线程，则处理机调度单位是（）
> 
> A. 线程
> 
> B. 进程
> 
> C. 程序
> 
> D. 作业

**答案：B**

**题目解析：**

A：用户态线程，线程堆操作系统是不可见的，操作系统只能调度进程。（如果系统中有内核态线程，则操作系统可以按线程进行调度）

B：进程可见。

C：程序属于系统中可执行的静态文件，不属于运行时，排除。

D：作业：一个作业通常包括几个进程，几个进程共同完成一个任务，是不可见的。

所以选择B选项。

> 31. 一个在线服务器通常需要读取存储着海量数据的数据库。为了提高服务器处理速度，通常需要加cache（缓存），以下场景中不适合使用cache的是（）
> 
> A. 数据库中每条数据被访问的概率近似相等，且独立
> 
> B. 使用了多线程机制的服务
> 
> C. 单条线程尺寸太小的数据
> 
> D. 有着大量访问的服务

**答案：A**

**题目解析：**

A：因为数据库中每条数据被访问的概率近似相等，且缓存空间一般较小不可能存入较多数据，无法预测所需要查询的数据，如果将被最近访问数据放入缓存用处不大，故而增加缓存起不到很大的作用，选择A选项。

> 32. 在支持多线程的系统中，进程P创建的若干个线程不能共享的是（ ）
> 
> A. 进程 P 的代码段
> 
> B. 进程 P 中打开的文件
> 
> C. 进程 P 的全局变量
> 
> D. 进程 P 中某线程的栈指针

**答案：D**

**题目解析：**

可以共享：代码段，打开的文件，全局变量。

栈指针是线程私有的，不可以共享。

所以选择D选项。

> 33. 当系统发生抖动（thrashing）时，可以采取的有效措施是（ ）
> 
> Ⅰ．撤销部分进程
> 
> Ⅱ．增加磁盘交换区的容量
> 
> Ⅲ．提高用户进程的优先级
> 
> A. 仅Ⅰ
> 
> B. 仅Ⅱ
> 
> C. 仅Ⅲ
> 
> D. 仅Ⅰ， Ⅱ

**答案：A**

**题目解析：**

在具有对换功能的操作系统中，通常把外存分为文件区和对换区，前者用于存放文件，后者用于存放从内存换出的进程。

抖动现象是指刚刚被换出的页很快又要被访问，为此又要换出其他页，而该换出页又快被访问，如此频繁地置换页面，以致大部分时间都花在页面置换上。

I：撤销部分进程可以减少所要用到的页面数，防止抖动。

II：抖动存在于虚拟内存，是存在于主存的，所以对换区大小和抖动无关。

III：优先级决定了系统调度时调度的顺序，和换页无关。

所以只有I有效，选择A选项。

> 34. 在下列进程的四个特征中，最基本的特征是（）
> 
> A. 并发性
> 
> B. 动态性
> 
> C. 独立性
> 
> D. 异步性

**答案：B**

**题目解析：**

最基本的特征是动态性，选择B。

> 35. 下面有关Cache的说法哪一个是不正确的（）
> 
> A. 设置Cache的目的，是解决CPU和主存之间的速度匹配问题
> 
> B. 设置Cache的理论基础，是程序访问的局部性原理
> 
> C. Cache与主存统一编址，Cache的地址空间属于主存的一部分
> 
> D. Cache的功能均由硬件实现，对程序员是透明的

**答案：C**

**题目解析：**

A：Cache出现的原因就是为了解决CPU与主存之间的速度匹配问题，CPU速度>Cache速度>主存速度。

B：局部性原理：一个程序在运行的某一时段，它访问的代码或数据大部分是集中在某一块区域的。

C：Cache的地址与主存的地址是两码事，不统一编址，也没有从属关系。

D：Cache是由硬件实现。

所以，C选项错误。

> 36. 以下哪句的说法是正确的？
> 
> A. 在页式存储管理中，用户应将自己的程序划分为若干个相等的页
> 
> B. 所有的进程都挂起时，系统将陷入死锁
> 
> C. 执行系统调用可以被中断
> 
> D. 进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变

**答案：C**

**题目解析：**

A：页的划分是操作系统做的。

B：死锁必须满足四个条件：互斥，循环等待，不剥夺，请求与保持。所有进程都挂起，并不表示这些进程间有资源调用和循环等待的关系，有些进程定时器结束后可能自动唤醒。

C：系统函数调用可以被其他优先级更高的进程或线程中断。

D：进程优先数指的是优先级的数量，取值范围是数字0~10，存在静态优先级调度，不会动态改变。

所以选择C选项。

[d5bd688297eb428f94f0a352f4c889af.png]: https://img-blog.csdnimg.cn/d5bd688297eb428f94f0a352f4c889af.png
[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/1450?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E8%BF%9B%E7%A8%8B/382503?fromModule=lemma_inlink
[PCB]: https://baike.baidu.com/item/PCB/16067368?fromModule=lemma_inlink