第3章 深入解析：现代操作系统原理及应用实践
计算机科学中，操作系统是连接用户与硬件的桥梁，它管理着计算机资源并为应用程序提供执行环境。本章将深入剖析操作系统的核心概念、发展历程和实现机制，帮助读者全面理解现代操作系统的工作原理。
3.1 操作系统的核心目标与基本功能
操作系统作为计算机系统中最基础的软件层，承担着多重角色与职责。理解其设计目标和功能对于掌握整个计算机系统至关重要。
3.1.1 操作系统作为人机交互界面
操作系统首要目标是提供友好的用户界面，使人们能够方便地与计算机系统交互。这一界面可以是命令行界面(CLI)，也可以是图形用户界面(GUI)。
作为人机交互界面，操作系统实现了以下功能：
- 接收并解释用户命令
- 启动和管理应用程序
- 提供文件管理功能
- 处理输入/输出操作
c
// 简单的命令行界面示例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_COMMAND_LENGTH 100
#define MAX_ARGS 10
void execute_command(char* command, char* args[]) {
if (strcmp(command, "echo") == 0) {
// 实现echo命令
for (int i = 0; args[i] != NULL; i++) {
printf("%s ", args[i]);
}
printf("\n");
} else if (strcmp(command, "exit") == 0) {
printf("Exiting shell...\n");
exit(0);
} else {
printf("Unknown command: %s\n", command);
}
}
int main() {
char input[MAX_COMMAND_LENGTH];
char* command;
char* args[MAX_ARGS];
while (1) {
printf("MyOS> "); // 命令提示符
fgets(input, MAX_COMMAND_LENGTH, stdin);
// 移除换行符
input[strcspn(input, "\n")] = 0;
// 解析命令
command = strtok(input, " ");
if (command == NULL) continue;
// 解析参数
int i = 0;
while ((args[i] = strtok(NULL, " ")) != NULL && i < MAX_ARGS - 1) {
i++;
}
args[i] = NULL; // 参数列表以NULL结尾
// 执行命令
execute_command(command, args);
}
return 0;
}
3.1.2 操作系统作为系统资源调度器
操作系统的另一个核心目标是有效管理计算机资源，包括CPU时间、内存空间、存储设备、输入/输出设备等。通过合理分配这些资源，操作系统确保系统高效运行并防止资源冲突。
资源管理功能包括：
- CPU调度，决定哪个进程获得处理器时间
- 内存管理，分配和回收内存空间
- 设备管理，控制外部设备的访问和使用
- 文件系统管理，组织和维护存储数据
c
// 简单的内存分配管理示例
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MEMORY_SIZE 1024 // 模拟1024字节内存
typedef struct MemoryBlock {
int start_address;
int size;
bool is_allocated;
struct MemoryBlock* next;
} MemoryBlock;
MemoryBlock* memory_list = NULL;
void initialize_memory() {
// 初始化一个空闲内存块
memory_list = (MemoryBlock*)malloc(sizeof(MemoryBlock));
memory_list->start_address = 0;
memory_list->size = MEMORY_SIZE;
memory_list->is_allocated = false;
memory_list->next = NULL;
}
void* my_malloc(int size) {
MemoryBlock* current = memory_list;
MemoryBlock* suitable_block = NULL;
// 首次适应算法
while (current != NULL) {
if (!current->is_allocated && current->size >= size) {
suitable_block = current;
break;
}
current = current->next;
}
if (suitable_block == NULL) {
printf("内存分配失败：没有足够空间\n");
return NULL;
}
// 如果找到的块大小大于请求大小，分割它
if (suitable_block->size > size) {
MemoryBlock* new_block = (MemoryBlock*)malloc(sizeof(MemoryBlock));
new_block->start_address = suitable_block->start_address + size;
new_block->size = suitable_block->size - size;
new_block->is_allocated = false;
new_block->next = suitable_block->next;
suitable_block->size = size;
suitable_block->next = new_block;
}
suitable_block->is_allocated = true;
// 返回模拟的内存地址
printf("分配内存：地址 %d, 大小 %d\n", suitable_block->start_address, size);
return (void*)(long)(suitable_block->start_address);
}
void my_free(void* ptr) {
int address = (int)(long)ptr;
MemoryBlock* current = memory_list;
// 查找对应的内存块
while (current != NULL) {
if (current->start_address == address) {
current->is_allocated = false;
printf("释放内存：地址 %d, 大小 %d\n", current->start_address, current->size);
// 合并相邻的空闲块
MemoryBlock* block = memory_list;
while (block != NULL && block->next != NULL) {
if (!block->is_allocated && !block->next->is_allocated) {
MemoryBlock* temp = block->next;
block->size += temp->size;
block->next = temp->next;
free(temp);
} else {
block = block->next;
}
}
return;
}
current = current->next;
}
printf("释放内存失败：地址 %d 不存在\n", address);
}
void print_memory_status() {
MemoryBlock* current = memory_list;
printf("\n内存状态：\n");
while (current != NULL) {
printf("地址：%d, 大小：%d, 状态：%s\n",
current->start_address,
current->size,
current->is_allocated ? "已分配" : "空闲");
current = current->next;
}
printf("\n");
}
3.1.3 操作系统的可扩展性设计
现代操作系统设计中，可扩展性是一个关键考量。良好的可扩展性设计允许系统在不需要重大重构的情况下适应新硬件、新功能和不断变化的需求。
可扩展性设计原则包括：
- 模块化架构，将系统功能分解为独立模块
- 抽象层设计，隐藏底层实现细节
- 标准化接口，确保组件间通信一致性
- 动态加载能力，支持插件和驱动程序扩展
c
// 模块化设计示例 - 设备驱动框架
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 设备驱动接口
typedef struct {
char* name;
int (*init)(void);
int (*read)(char* buffer, int size);
int (*write)(const char* buffer, int size);
int (*close)(void);
} DeviceDriver;
#define MAX_DRIVERS 10
DeviceDriver* registered_drivers[MAX_DRIVERS];
int driver_count = 0;
// 注册驱动程序
int register_driver(DeviceDriver* driver) {
if (driver_count >= MAX_DRIVERS) {
printf("驱动注册失败：驱动数量已达上限\n");
return -1;
}
registered_drivers[driver_count++] = driver;
printf("驱动已注册：%s\n", driver->name);
return 0;
}
// 查找驱动程序
DeviceDriver* find_driver(const char* name) {
for (int i = 0; i < driver_count; i++) {
if (strcmp(registered_drivers[i]->name, name) == 0) {
return registered_drivers[i];
}
}
return NULL;
}
// 示例设备驱动实现
int console_init(void) {
printf("控制台初始化\n");
return 0;
}
int console_read(char* buffer, int size) {
printf("从控制台读取数据\n");
// 实际实现会从控制台读取输入
strcpy(buffer, "Hello from console");
return strlen(buffer);
}
int console_write(const char* buffer, int size) {
printf("向控制台写入数据: %s\n", buffer);
return size;
}
int console_close(void) {
printf("关闭控制台\n");
return 0;
}
// 创建控制台驱动
DeviceDriver console_driver = {
"console",
console_init,
console_read,
console_write,
console_close
};
3.2 操作系统的演进历程
操作系统的发展历程反映了计算机科学和技术的整体进步，从最早的批处理系统到现代的分布式操作系统，每一步演进都带来了重要的技术创新。
3.2.1 单任务处理系统
最早的操作系统是简单的单任务处理系统，一次只能运行一个程序。用户需要将程序装载到计算机中，系统运行完成后才能开始下一个任务。这种系统简单但效率低下，CPU和I/O设备的利用率很低。
c
// 模拟单任务处理系统
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void run_program(const char* program_name) {
printf("开始执行程序: %s\n", program_name);
// 模拟程序执行
printf("程序 %s 正在运行...\n", program_name);
sleep(2); // 模拟执行时间
printf("程序 %s 执行完成\n\n", program_name);
}
int main() {
printf("=== 单任务处理系统启动 ===\n\n");
// 顺序执行多个程序
run_program("WordProcessor");
run_program("Calculator");
run_program("Compiler");
printf("=== 系统关闭 ===\n");
return 0;
}
3.2.2 基础批处理系统
为了提高计算机的利用效率，批处理系统被开发出来。这种系统允许操作员将多个作业一次性提交给计算机，系统自动依次处理这些作业，无需人工干预。这大大提高了计算机的吞吐量。
c
// 模拟简单批处理系统
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct {
char name[50];
int duration; // 执行时间(秒)
} Job;
#define MAX_JOBS 10
Job job_queue[MAX_JOBS];
int job_count = 0;
void submit_job(const char* name, int duration) {
if (job_count >= MAX_JOBS) {
printf("作业队列已满，无法提交新作业\n");
return;
}
strcpy(job_queue[job_count].name, name);
job_queue[job_count].duration = duration;
job_count++;
printf("作业 '%s' 已提交到批处理队列\n", name);
}
void run_batch_jobs() {
printf("\n=== 开始批处理作业 ===\n");
for (int i = 0; i < job_count; i++) {
printf("\n开始执行作业: %s\n", job_queue[i].name);
printf("作业 %s 运行中...\n", job_queue[i].name);
// 模拟作业执行
sleep(job_queue[i].duration);
printf("作业 %s 已完成\n", job_queue[i].name);
}
printf("\n=== 批处理作业全部完成 ===\n");
job_count = 0; // 清空作业队列
}
int main() {
printf("=== 简单批处理系统启动 ===\n\n");
// 提交作业
submit_job("数据分析", 3);
submit_job("文件编译", 2);
submit_job("报表生成", 4);
// 运行批处理作业
run_batch_jobs();
printf("=== 系统关闭 ===\n");
return 0;
}
3.2.3 多道程序处理系统
批处理系统的一个问题是CPU在等待I/O操作时仍然空闲。多道程序设计通过在内存中同时保存多个程序，在一个程序等待I/O时切换到另一个程序执行，从而提高CPU利用率。
c
// 多道程序系统模拟
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#define MAX_PROGRAMS 5
typedef enum {
READY,
RUNNING,
WAITING,
TERMINATED
} ProgramState;
typedef struct {
char name[50];
ProgramState state;
int cpu_burst_time; // 需要的CPU时间
int io_burst_time; // I/O操作时间
int remaining_cpu; // 剩余CPU时间
int remaining_io; // 剩余I/O时间
} Program;
Program programs[MAX_PROGRAMS];
int program_count = 0;
int current_program = -1;
void add_program(const char* name, int cpu_time, int io_time) {
if (program_count >= MAX_PROGRAMS) {
printf("程序数量已达上限\n");
return;
}
strcpy(programs[program_count].name, name);
programs[program_count].state = READY;
programs[program_count].cpu_burst_time = cpu_time;
programs[program_count].io_burst_time = io_time;
programs[program_count].remaining_cpu = cpu_time;
programs[program_count].remaining_io = io_time;
program_count++;
printf("添加程序: %s (CPU时间:%d, I/O时间:%d)\n",
name, cpu_time, io_time);
}
void simulate_multiprogramming() {
int time = 0;
bool all_terminated = false;
printf("\n=== 开始多道程序模拟 ===\n\n");
while (!all_terminated) {
printf("时间点: %d\n", time);
// 处理I/O完成的程序
for (int i = 0; i < program_count; i++) {
if (programs[i].state == WAITING) {
programs[i].remaining_io--;
if (programs[i].remaining_io <= 0) {
printf("程序 %s 的I/O操作完成\n", programs[i].name);
programs[i].state = READY;
}
}
}
// 如果当前没有运行的程序，选择一个就绪的程序运行
if (current_program == -1 || programs[current_program].state != RUNNING) {
current_program = -1;
for (int i = 0; i < program_count; i++) {
if (programs[i].state == READY) {
current_program = i;
programs[i].state = RUNNING;
printf("切换到程序: %s\n", programs[i].name);
break;
}
}
}
// 运行当前程序
if (current_program != -1 && programs[current_program].state == RUNNING) {
programs[current_program].remaining_cpu--;
printf("程序 %s 执行中 (剩余CPU时间: %d)\n",
programs[current_program].name,
programs[current_program].remaining_cpu);
if (programs[current_program].remaining_cpu <= 0) {
if (programs[current_program].remaining_io > 0) {
printf("程序 %s 等待I/O操作 (I/O时间: %d)\n",
programs[current_program].name,
programs[current_program].remaining_io);
programs[current_program].state = WAITING;
} else {
printf("程序 %s 执行完成\n", programs[current_program].name);
programs[current_program].state = TERMINATED;
}
current_program = -1;
}
}
// 检查是否所有程序都已终止
all_terminated = true;
for (int i = 0; i < program_count; i++) {
if (programs[i].state != TERMINATED) {
all_terminated = false;
break;
}
}
time++;
printf("\n");
sleep(1); // 放慢模拟速度，便于观察
}
printf("=== 所有程序执行完毕 ===\n");
}
int main() {
printf("=== 多道程序系统模拟 ===\n\n");
add_program("编译器", 3, 2);
add_program("文字处理", 2, 3);
add_program("数据库查询", 4, 4);
simulate_multiprogramming();
return 0;
}
3.2.4 时间共享系统
时间共享是多道程序设计的一种扩展，它允许多个用户同时与计算机交互，给每个用户一种独占计算机的错觉。系统通过快速在各用户程序间切换，使每个用户都能获得及时响应。
c
// 时间共享系统模拟
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define MAX_PROCESSES 10
#define TIME_SLICE 2 // 时间片长度(秒)
typedef struct {
char name[50];
int priority; // 优先级
int remaining_time; // 剩余执行时间
int response_time; // 响应时间计数器
} Process;
Process processes[MAX_PROCESSES];
int process_count = 0;
void add_process(const char* name, int priority, int execution_time) {
if (process_count >= MAX_PROCESSES) {
printf("进程数量已达上限\n");
return;
}
strcpy(processes[process_count].name, name);
processes[process_count].priority = priority;
processes[process_count].remaining_time = execution_time;
processes[process_count].response_time = 0;
process_count++;
printf("添加进程: %s (优先级:%d, 执行时间:%d)\n",
name, priority, execution_time);
}
void simulate_time_sharing() {
int time = 0;
int active_processes = process_count;
printf("\n=== 开始时间共享系统模拟 ===\n\n");
while (active_processes > 0) {
printf("时间点: %d\n", time);
// 找出优先级最高的进程
int highest_priority = -1;
int selected_process = -1;
for (int i = 0; i < process_count; i++) {
// 更新所有活跃进程的响应时间
if (processes[i].remaining_time > 0) {
processes[i].response_time++;
}
// 选择优先级高且有剩余时间的进程
if (processes[i].remaining_time > 0 &&
(selected_process == -1 ||
processes[i].priority > highest_priority)) {
selected_process = i;
highest_priority = processes[i].priority;
}
}
if (selected_process != -1) {
// 执行选中的进程一个时间片
int execution_time = TIME_SLICE;
if (processes[selected_process].remaining_time < TIME_SLICE) {
execution_time = processes[selected_process].remaining_time;
}
printf("执行进程: %s (剩余时间: %d, 响应时间: %d)\n",
processes[selected_process].name,
processes[selected_process].remaining_time,
processes[selected_process].response_time);
// 更新进程剩余时间
processes[selected_process].remaining_time -= execution_time;
processes[selected_process].response_time = 0; // 重置响应时间
// 检查进程是否完成
if (processes[selected_process].remaining_time <= 0) {
printf("进程 %s 执行完成\n",
processes[selected_process].name);
active_processes--;
}
}
time += TIME_SLICE;
printf("\n");
sleep(1); // 放慢模拟速度
}
printf("=== 所有进程执行完毕 ===\n");
}
int main() {
printf("=== 时间共享系统模拟 ===\n\n");
add_process("用户1-文本编辑", 5, 8);
add_process("用户2-编译程序", 8, 10);
add_process("用户3-网页浏览", 3, 6);
add_process("系统-后台任务", 1, 12);
simulate_time_sharing();
return 0;
}
3.3 操作系统的关键成果
现代操作系统通过多项技术创新解决了计算机资源管理和用户交互的核心问题。这些成就构成了现代操作系统的基础。
3.3.1 进程管理技术
进程是计算机科学中最基本的概念之一，是一个正在执行的程序实例，包含代码、数据和系统资源。操作系统负责进程的创建、调度、同步和终止。
进程管理技术包括：
- 进程创建和终止
- 进程间通信(IPC)
- 进程同步和互斥
- 死锁预防和处理
c
// 进程创建和IPC示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main() {
int pipe_fd[2]; // 管道文件描述符
pid_t pid;
char buffer[100];
// 创建管道
if (pipe(pipe_fd) == -1) {
perror("管道创建失败");
exit(EXIT_FAILURE);
}
// 创建子进程
pid = fork();
if (pid < 0) {
perror("进程创建失败");
exit(EXIT_FAILURE);
}
if (pid == 0) {
// 子进程代码
printf("子进程 (PID: %d) 开始执行\n", getpid());
// 关闭读端
close(pipe_fd[0]);
// 向管道写入数据
const char* message = "Hello from child process!";
write(pipe_fd[1], message, strlen(message) + 1);
printf("子进程发送消息: %s\n", message);
// 关闭写端
close(pipe_fd[1]);
printf("子进程执行完毕\n");
exit(EXIT_SUCCESS);
} else {
// 父进程代码
printf("父进程 (PID: %d) 开始执行，子进程PID: %d\n", getpid(), pid);
// 关闭写端
close(pipe_fd[1]);
// 从管道读取数据
read(pipe_fd[0], buffer, sizeof(buffer));
printf("父进程收到消息: %s\n", buffer);
// 关闭读端
close(pipe_fd[0]);
// 等待子进程结束
wait(NULL);
printf("父进程执行完毕\n");
}
return 0;
}
3.3.2 内存管理系统
内存管理是操作系统的核心功能，它负责分配和回收物理内存，以及实现虚拟内存机制，使每个进程认为自己拥有连续的地址空间。
主要内存管理技术包括：
- 固定分区和动态分区分配
- 分页和分段
- 虚拟内存和页面置换
- 内存保护机制
c
// 简单的分页内存管理模拟
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define PAGE_SIZE 4096 // 页大小(字节)
#define NUM_FRAMES 128 // 物理内存帧数
#define NUM_PAGES 256 // 虚拟内存页数
// 页表项
typedef struct {
bool valid; // 页是否在物理内存中
int frame; // 对应的物理帧号
bool modified; // 是否被修改
bool referenced; // 是否被访问
} PageTableEntry;
// 页表
PageTableEntry page_table[NUM_PAGES];
// 物理内存帧的使用情况
bool frame_used[NUM_FRAMES];
// 初始化内存管理系统
void init_memory_system() {
// 初始化页表
for (int i = 0; i < NUM_PAGES; i++) {
page_table[i].valid = false;
page_table[i].frame = -1;
page_table[i].modified = false;
page_table[i].referenced = false;
}
// 初始化物理帧使用情况
for (int i = 0; i < NUM_FRAMES; i++) {
frame_used[i] = false;
}
printf("内存管理系统初始化完成\n");
}
// 分配物理帧
int allocate_frame() {
for (int i = 0; i < NUM_FRAMES; i++) {
if (!frame_used[i]) {
frame_used[i] = true;
return i;
}
}
return -1; // 没有空闲帧
}
// 内存访问
void* memory_access(int virtual_address, bool is_write) {
int page_number = virtual_address / PAGE_SIZE;
int offset = virtual_address % PAGE_SIZE;
printf("访问虚拟地址: 0x%X (页号: %d, 偏移: %d)\n",
virtual_address, page_number, offset);
if (page_number < 0 || page_number >= NUM_PAGES) {
printf("错误: 无效的虚拟地址\n");
return NULL;
}
// 检查页是否在物理内存中
if (!page_table[page_number].valid) {
// 页面错误
printf("页面错误: 页 %d 不在物理内存中\n", page_number);
// 分配物理帧
int frame = allocate_frame();
if (frame == -1) {
// 物理内存已满，需要页面置换(这里简化处理)
printf("物理内存已满，需要页面置换\n");
return NULL;
}
// 将页加载到物理内存
printf("将页 %d 加载到物理帧 %d\n", page_number, frame);
page_table[page_number].valid = true;
page_table[page_number].frame = frame;
}
// 更新页表项
page_table[page_number].referenced = true;
if (is_write) {
page_table[page_number].modified = true;
}
// 计算物理地址
int physical_address = page_table[page_number].frame * PAGE_SIZE + offset;
printf("转换为物理地址: 0x%X (帧号: %d, 偏移: %d)\n",
physical_address, page_table[page_number].frame, offset);
// 返回指向物理内存的指针(模拟)
return (void*)(long)physical_address;
}
// 释放页面
void free_page(int page_number) {
if (page_number < 0 || page_number >= NUM_PAGES) {
printf("错误: 无效的页号\n");
return;
}
if (page_table[page_number].valid) {
int frame = page_table[page_number].frame;
// 如果页面被修改，需要写回到磁盘
if (page_table[page_number].modified) {
printf("页 %d 被修改，写回到磁盘\n", page_number);
}
// 释放物理帧
frame_used[frame] = false;
// 更新页表
page_table[page_number].valid = false;
page_table[page_number].frame = -1;
page_table[page_number].modified = false;
page_table[page_number].referenced = false;
printf("释放页 %d 对应的物理帧 %d\n", page_number, frame);
} else {
printf("页 %d 不在物理内存中，无需释放\n", page_number);
}
}
3.3.3 信息安全与保护机制
现代操作系统必须提供强大的安全和保护机制，防止未授权访问和恶意行为。这些机制保护系统资源、用户数据和应用程序免受攻击。
主要安全机制包括：
- 用户认证和授权
- 访问控制和权限管理
- 内存保护和沙箱
- 加密和隐私保护
c
// 简单的访问控制列表(ACL)实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAX_USERS 10
#define MAX_FILES 20
#define MAX_NAME_LENGTH 30
// 权限类型
typedef enum {
READ = 0x1, // 001
WRITE = 0x2, // 010
EXECUTE = 0x4 // 100
} Permission;
// 用户
typedef struct {
char username[MAX_NAME_LENGTH];
char password[MAX_NAME_LENGTH]; // 实际应存储哈希值
bool is_admin;
} User;
// 文件
typedef struct {
char filename[MAX_NAME_LENGTH];
char owner[MAX_NAME_LENGTH];
int permissions[MAX_USERS]; // 每个用户的权限
} File;
User users[MAX_USERS];
File files[MAX_FILES];
int user_count = 0;
int file_count = 0;
int current_user = -1; // 当前登录用户的索引
// 添加用户
bool add_user(const char* username, const char* password, bool is_admin) {
if (user_count >= MAX_USERS) {
printf("用户数量已达上限\n");
return false;
}
// 检查用户名是否已存在
for (int i = 0; i < user_count; i++) {
if (strcmp(users[i].username, username) == 0) {
printf("用户名已存在\n");
return false;
}
}
strcpy(users[user_count].username, username);
strcpy(users[user_count].password, password); // 实际应存储哈希值
users[user_count].is_admin = is_admin;
user_count++;
printf("用户 '%s' 创建成功\n", username);
return true;
}
// 用户登录
bool login(const char* username, const char* password) {
for (int i = 0; i < user_count; i++) {
if (strcmp(users[i].username, username) == 0 &&
strcmp(users[i].password, password) == 0) {
current_user = i;
printf("用户 '%s' 登录成功\n", username);
return true;
}
}
printf("用户名或密码错误\n");
return false;
}
// 创建文件
bool create_file(const char* filename) {
if (current_user == -1) {
printf("请先登录\n");
return false;
}
if (file_count >= MAX_FILES) {
printf("文件数量已达上限\n");
return false;
}
// 检查文件名是否已存在
for (int i = 0; i < file_count; i++) {
if (strcmp(files[i].filename, filename) == 0) {
printf("文件名已存在\n");
return false;
}
}
strcpy(files[file_count].filename, filename);
strcpy(files[file_count].owner, users[current_user].username);
// 设置默认权限：所有者有全部权限，其他用户无权限
for (int i = 0; i < MAX_USERS; i++) {
files[file_count].permissions[i] = 0;
}
files[file_count].permissions[current_user] = READ | WRITE | EXECUTE;
file_count++;
printf("文件 '%s' 创建成功\n", filename);
return true;
}
// 设置文件权限
bool set_file_permission(const char* filename, const char* username, int permission) {
if (current_user == -1) {
printf("请先登录\n");
return false;
}
// 查找文件
int file_index = -1;
for (int i = 0; i < file_count; i++) {
if (strcmp(files[i].filename, filename) == 0) {
file_index = i;
break;
}
}
if (file_index == -1) {
printf("文件不存在\n");
return false;
}
// 检查是否为文件所有者或管理员
if (strcmp(files[file_index].owner, users[current_user].username) != 0 &&
!users[current_user].is_admin) {
printf("权限不足，只有文件所有者或管理员可以修改权限\n");
return false;
}
// 查找目标用户
int user_index = -1;
for (int i = 0; i < user_count; i++) {
if (strcmp(users[i].username, username) == 0) {
user_index = i;
break;
}
}
if (user_index == -1) {
printf("用户不存在\n");
return false;
}
// 设置权限
files[file_index].permissions[user_index] = permission;
printf("已设置用户 '%s' 对文件 '%s' 的权限\n", username, filename);
return true;
}
// 访问文件
bool access_file(const char* filename, Permission access_type) {
if (current_user == -1) {
printf("请先登录\n");
return false;
}
// 查找文件
int file_index = -1;
for (int i = 0; i < file_count; i++) {
if (strcmp(files[i].filename, filename) == 0) {
file_index = i;
break;
}
}
if (file_index == -1) {
printf("文件不存在\n");
return false;
}
// 管理员可以访问任何文件
if (users[current_user].is_admin) {
printf("管理员 '%s' 访问文件 '%s' 成功\n",
users[current_user].username, filename);
return true;
}
// 检查权限
if ((files[file_index].permissions[current_user] & access_type) == 0) {
printf("权限不足，无法%s文件 '%s'\n",
access_type == READ ? "读取" :
access_type == WRITE ? "写入" : "执行",
filename);
return false;
}
printf("用户 '%s' %s文件 '%s' 成功\n",
users[current_user].username,
access_type == READ ? "读取" :
access_type == WRITE ? "写入" : "执行",
filename);
return true;
}
3.3.4 调度与资源分配算法
操作系统使用各种调度和资源分配算法来优化系统性能，包括CPU调度、内存分配、I/O调度和网络带宽分配等。
常见的调度算法包括：
- 先来先服务(FCFS)
- 短作业优先(SJF)
- 优先级调度
- 轮转调度(Round Robin)
- 多级队列调度
c
// CPU调度算法模拟
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAX_PROCESSES 10
// 进程状态
typedef enum {
NEW,
READY,
RUNNING,
WAITING,
TERMINATED
} ProcessState;
// 进程控制块
typedef struct {
char name[20];
int pid;
int arrival_time; // 到达时间
int burst_time; // 需要的CPU时间
int remaining_time; // 剩余执行时间
int priority; // 优先级(数值越小优先级越高)
int waiting_time; // 等待时间
int turnaround_time; // 周转时间
ProcessState state; // 进程状态
} PCB;
PCB processes[MAX_PROCESSES];
int process_count = 0;
// 添加进程
void add_process(const char* name, int arrival_time, int burst_time, int priority) {
if (process_count >= MAX_PROCESSES) {
printf("进程数量已达上限\n");
return;
}
strcpy(processes[process_count].name, name);
processes[process_count].pid = process_count + 1000;
processes[process_count].arrival_time = arrival_time;
processes[process_count].burst_time = burst_time;
processes[process_count].remaining_time = burst_time;
processes[process_count].priority = priority;
processes[process_count].waiting_time = 0;
processes[process_count].turnaround_time = 0;
processes[process_count].state = NEW;
pro
最低0.47元/天 解锁文章
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
