正文

计算机入门必看：操作系统04篇，轻松掌握系统核心功能！

/0 浏览量
0401

操作系统是计算机的心脏，它负责管理计算机的硬件和软件资源，确保计算机高效、稳定地运行。本篇将带您深入了解操作系统的核心功能，帮助您轻松掌握系统运作的奥秘。

1. 进程管理

进程是操作系统进行资源分配和调度的基本单位。进程管理包括进程的创建、调度、同步和通信等。

1.1 进程的创建

进程的创建是通过系统调用实现的。在创建进程时，操作系统会为进程分配必要的资源，如内存、文件描述符等。

#include <unistd.h>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        execlp("ls", "ls", NULL);
    } else {
        // 父进程
        wait(NULL);
    }
    return 0;
}

1.2 进程的调度

进程调度是指操作系统根据一定的算法，从就绪队列中选择一个进程来执行。常见的调度算法有先来先服务（FCFS）、短作业优先（SJF）等。

// 示例：使用FCFS算法进行进程调度
#define MAX_PROCESSES 5

struct process {
    int id;
    int arrival_time;
    int burst_time;
};

void fcfs(struct process processes[], int n) {
    int total_time = 0;
    for (int i = 0; i < n; i++) {
        total_time += processes[i].burst_time;
        printf("Process %d: %d\n", processes[i].id, total_time);
    }
}

int main() {
    struct process processes[MAX_PROCESSES] = {
        {1, 0, 3},
        {2, 1, 6},
        {3, 4, 4},
        {4, 6, 5},
        {5, 8, 2}
    };
    fcfs(processes, MAX_PROCESSES);
    return 0;
}

1.3 进程的同步

进程同步是指进程之间协调执行，以避免出现竞争条件和死锁等问题。常见的同步机制有互斥锁、信号量等。

#include <pthread.h>

pthread_mutex_t lock;

void* thread_func(void* arg) {
    pthread_mutex_lock(&lock);
    // 临界区代码
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&lock, NULL);
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&lock);
    return 0;
}

1.4 进程的通信

进程通信是指进程之间交换信息和数据。常见的通信机制有管道、消息队列、共享内存等。

#include <unistd.h>
#include <stdio.h>

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t cpid = fork();
    if (cpid == -1) {
        perror("fork");
        return 1;
    }

    if (cpid == 0) {
        // 子进程
        close(pipefd[0]);
        write(pipefd[1], "Hello, world!\n", 13);
        close(pipefd[1]);
    } else {
        // 父进程
        close(pipefd[1]);
        char buffer[1024];
        read(pipefd[0], buffer, 1024);
        printf("%s", buffer);
        close(pipefd[0]);
    }

    return 0;
}

2. 内存管理

内存管理是操作系统的重要功能之一，负责分配、回收和管理内存资源。

2.1 内存分配

内存分配是指操作系统根据进程的需求，为进程分配相应的内存空间。常见的内存分配策略有固定分区、动态分区、分页等。

// 示例：使用固定分区分配内存
#define MAX_PARTITIONS 3
#define PARTITION_SIZE 1024

struct partition {
    int start;
    int end;
    int is_used;
};

void allocate_memory(struct partition partitions[], int n, int process_size) {
    int i;
    for (i = 0; i < n; i++) {
        if (!partitions[i].is_used && partitions[i].end - partitions[i].start >= process_size) {
            partitions[i].is_used = 1;
            printf("Process allocated in partition %d\n", i);
            break;
        }
    }
}

int main() {
    struct partition partitions[MAX_PARTITIONS] = {
        {0, PARTITION_SIZE, 0},
        {PARTITION_SIZE, 2 * PARTITION_SIZE, 0},
        {2 * PARTITION_SIZE, 3 * PARTITION_SIZE, 0}
    };
    allocate_memory(partitions, MAX_PARTITIONS, 512);
    return 0;
}

2.2 内存回收

内存回收是指操作系统回收不再使用的内存空间，以便重新分配给其他进程。

// 示例：释放内存
#define MAX_PARTITIONS 3
#define PARTITION_SIZE 1024

struct partition {
    int start;
    int end;
    int is_used;
};

void free_memory(struct partition partitions[], int n, int partition_index) {
    partitions[partition_index].is_used = 0;
    printf("Partition %d freed\n", partition_index);
}

int main() {
    struct partition partitions[MAX_PARTITIONS] = {
        {0, PARTITION_SIZE, 1},
        {PARTITION_SIZE, 2 * PARTITION_SIZE, 1},
        {2 * PARTITION_SIZE, 3 * PARTITION_SIZE, 1}
    };
    free_memory(partitions, MAX_PARTITIONS, 0);
    return 0;
}

2.3 内存保护

内存保护是指操作系统为进程提供一定的内存保护机制，防止进程访问非法内存空间。

// 示例：使用内存保护机制
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int* protected_memory = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (protected_memory == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    // 修改内存
    *protected_memory = 42;

    // 尝试访问非法内存
    int* illegal_memory = (int*)0x1000;
    *illegal_memory = 24;

    munmap(protected_memory, 1024);
    return 0;
}

3. 文件系统

文件系统是操作系统管理文件和目录的机制。它负责文件的创建、删除、读写和目录的建立、删除等操作。

3.1 文件创建

文件创建是指操作系统为进程创建一个新的文件。

#include <stdio.h>

int main() {
    FILE* file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("fopen");
        return 1;
    }

    fprintf(file, "Hello, world!\n");
    fclose(file);
    return 0;
}

3.2 文件删除

文件删除是指操作系统从文件系统中删除一个文件。

#include <stdio.h>
#include <stdlib.h>

int main() {
    if (remove("example.txt") == 0) {
        printf("File deleted successfully\n");
    } else {
        perror("remove");
        return 1;
    }
    return 0;
}

3.3 文件读写

文件读写是指操作系统对文件进行读取和写入操作。

#include <stdio.h>

int main() {
    FILE* file = fopen("example.txt", "r");
    if (file == NULL) {
        perror("fopen");
        return 1;
    }

    char buffer[1024];
    while (fgets(buffer, sizeof(buffer), file)) {
        printf("%s", buffer);
    }

    fclose(file);
    return 0;
}

3.4 目录操作

目录操作是指操作系统对目录进行创建、删除、列出等操作。

#include <stdio.h>
#include <stdlib.h>

int main() {
    if (mkdir("new_directory", 0777) == 0) {
        printf("Directory created successfully\n");
    } else {
        perror("mkdir");
        return 1;
    }

    if (rmdir("new_directory") == 0) {
        printf("Directory deleted successfully\n");
    } else {
        perror("rmdir");
        return 1;
    }
    return 0;
}

通过本篇的介绍，相信您已经对操作系统的核心功能有了更深入的了解。希望这些知识能帮助您在计算机领域取得更好的成绩！

-- 展开阅读全文 --