【专栏必读】王道考研408操作系统+Linux系统编程万字笔记、题目题型总结、注意事项、目录导航和思维导图

置顶 已于 2024-06-01 21:24:40 修改
阅读量2.7w 收藏 541
点赞数 44
分类专栏： 408王道考研操作系统+Linux系统编程 文章标签： linux 王道 408 操作系统
于 2021-10-27 23:08:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39183034/article/details/121004242
版权
该笔记涵盖了王道考研408操作系统的所有章节，包括计算机系统概述、进程管理、内存管理和文件管理等内容，并结合Linux系统编程进行深入讲解，如进程控制、内存分配、I/O管理等。此外，还提供了Linux系统编程的实践指导，包括常用命令、进程通信、信号处理、多线程等，旨在帮助考研学生和Linux爱好者巩固理论知识并提升实践能力。
摘要由CSDN通过智能技术生成

其他科目导航

首先感谢王道大大（手动比心），很用心在做了，笔记会按照如下方式、特点记录，大家可以看看，介绍在后面

文章目录

一：必读

①：《计算机科学专业基础综合》（代码408） 想必每位计算机考研人都有所了解，虽然可能所考院校是自命题，但总会涉及408中的一种或多种。408会涉及如下4门课，它们各有特点

  • 《计算机组成原理》（占30%）：涉及硬件等底层知识、部分知识晦涩难懂
  • 《操作系统》（占23.3%）：计算机中的“哲学”，内容特别抽象，感觉“学了等于没学”
  • 《数据结构》（占30%）：最重要的一门课，逻辑性强，较为抽象，常和算法有关
  • 《计算机网络》（占16.7%）：关联知识较多（例如通信），所以知识点“又臭又长”

所以408难度确实不小，在180分钟内做完一套试卷犹如进行了一场战斗。而且最为关键的是考计算机一定会考数学，数学的复习几乎会占据你考研复习时间的一半（甚至更多），因为“得数学者得天下”

②：对于408的复习，市面上的授课机构主要是王道和天勤，它们两家真的都非常非常好，我都细心看过

  • 王道：知识点涵盖全面、讲解仔细
  • 天勤：讲解角度独特，动画制作精美，关键问题容易理解

而王道也把人家的课程全部上传至了B站，所以专栏笔记主体会基于王道进行，所以这里真的特别特别感谢王道

③：只有考研人才能懂考研人，所以我深知复习408的痛苦。面对海量的知识点你会感觉力不从心，尤其在前期，总是学了这一章忘了上一章，而且很多时候不同科目的知识经常搅到一起。因此，我花费了很长时间写了这些专栏笔记以帮助大家考研复习，有以下特点

  • 专栏笔记会按照视频课和课本的逻辑进行记录，会把老师课上所讲内容和课本进行结合，同时辅助一些自己在工作、学习中的想法

  • 说个实话，视频课中的内容是有点“乱”的，因为老师在讲课时是需要按照他的思路来进行的，所以我的目的就是要让其系统性（也即你会知道每一节究竟在干什么），便于同学查阅；同时有些知识点晦涩难懂，我会加入自己的理解便于大家学习

  • 所有笔记纯手打（课本+老师说的话+自己的理解），并不是视频课截图（当然有些图片肯定还是会采用截图）

  • 所有笔记会严格控制格式（主要就是公式和配色），力争做到清晰、简洁、整齐

  • 部分科目会配有题型讲解，大家可以在我主页处找到，这一部分还在更新

④：专栏会一直更新，主要是纠错和补充知识点

⑤：希望大家能够意识到学习这四门课并不是简简单单为了考研，只要你真心想要走计算机这条道路，它就是你的基本功

  • 就拿离你们最近的校招来说，其实70%的内容都是这些

⑥：“道阻且长、行则将至”，大家加油吧！

二：关于本专栏及学习建议

  • 标题是按照视频课走的，可能有些部分存在差异，因为部分视频课内容太少，不值得单独做一篇文章

  • 笔记主要以王道视频为主，少量会补充 《操作系统精髓与设计原理(第八版)》 中的内容。建议大家有时间可以读一读，十分经典
    在这里插入图片描述

  • 笔记是学好的必要条件，但不是充分条件

  • 记笔记的目的不是单纯的为了“记”，是为了以后复习时不需要太大的时间成本

  • 学习一门课就像开发一个程序一样，先搭框架，后解决细节问题。前期需要迅速建立一门学科的整体框架与逻辑，不会的可以直接跳，学完之后需要反复梳理

三：王道考研408操作系统导航

第一章：计算机系统概述、

第一节：操作系统的基本概念

(王道408考研操作系统)第一章计算机系统概述-第一节1、2：操作系统概念、概念和特征

第二节：操作系统的发展历程

(王道408考研操作系统)第一章计算机系统概述-第二节：操作系统的发展历程

第三节： 操作系统运行环境

(王道408考研操作系统)第一章计算机系统概述-第三节1：操作系统的运行机制与体系结构

(王道408考研操作系统)第一章计算机系统概述-第三节2：中断和异常

(王道408考研操作系统)第一章计算机系统概述-第三节3：系统调用

第四节：操作系统结构

(王道408考研操作系统)第一章计算机系统概述-第四节：操作系统体系结构

第五、六节：操作系统引导和虚拟机

(王道408考研操作系统)第一章计算机系统概述-第五节：操作系统引导

第二章：进程管理

第一节：进程与线程

((王道408考研操作系统)第二章进程管理-第一节1：进程的概念、组成和特征

(王道408考研操作系统)第二章进程管理-第一节2：进程状态与转换

(王道408考研操作系统)第二章进程管理-第一节3：进程控制（配合Linux讲解）

(王道408考研操作系统)第二章进程管理-第一节4：进程通信（配合Linux）

(王道408考研操作系统)第二章进程管理-第一节5：线程的概念

(王道408考研操作系统)第二章进程管理-第一节6、7：线程的实现方式、多线程模型、线程的状态与转换、线程的组织与控制

第二节：进程调度、分类及其调度算法等

(王道408考研操作系统)第二章进程管理-第二节1：调度的基本概念和层次

(王道408考研操作系统)第二章进程管理-第二节2、3：进程调度的时机、切换与过程、方式、调度器和闲逛进程

(王道408考研操作系统)第二章进程管理-第二节4：调度算法评价指标

(王道408考研操作系统)第二章进程管理-第二节5：调度算法详解1（FCFS、SJF和HRRN）

(王道408考研操作系统)第二章进程管理-第二节6、7：调度算法详解2(RR、HPF和MFQ)

第三节：进程同步和互斥、信号量及经典进程同步问题等

(王道408考研操作系统)第二章进程管理-第三节1：进程同步与互斥的基本概念

(王道408考研操作系统)第二章进程管理-第三节2：实现进程互斥的软件方法

(王道408考研操作系统)第二章进程管理-第三节3：实现进程互斥的硬件方法

(王道408考研操作系统)第二章进程管理-第三节4：信号量机制（整型、记录型信号量和P、V操作）

(王道408考研操作系统)第二章进程管理-第三节5：用信号量实现进程互斥、同步和前驱关系

(王道408考研操作系统)第二章进程管理-第三节6：经典同步问题之生产者与消费者问题

(王道408考研操作系统)第二章进程管理-第三节7：经典同步问题之多生产者与多消费者问题

(王道408考研操作系统)第二章进程管理-第三节8：经典同步问题之吸烟者问题

(王道408考研操作系统)第二章进程管理-第三节9：经典同步问题之读者写者问题

(王道408考研操作系统)第二章进程管理-第三节10：经典同步问题之哲学家进餐问题

(王道408考研操作系统)第二章进程管理-第三节11：管程(Monitor)及条件变量

第四节：死锁和避免死锁等

(王道408考研操作系统)第二章进程管理-第四节1：死锁相关概念

(王道408考研操作系统)第二章进程管理-第四节2：死锁处理策略之预防死锁

(王道408考研操作系统)第二章进程管理-第四节2：死锁处理策略之避免死锁（银行家算法）

(王道408考研操作系统)第二章进程管理-第四节3：死锁处理策略之检测和解除

第三章：内存管理

第一节：内存基本知识、分配管理方式等

(王道408考研操作系统)第三章内存管理-第一节1：内存基础知识、程序编译运行原理

(王道408考研操作系统)第三章内存管理-第一节2：内存管理的基本概念

(王道408考研操作系统)第三章内存管理-第一节3：覆盖与交换

(王道408考研操作系统)第三章内存管理-第一节4：连续分配管理方式(单一连续、固定分区和动态分区分配)

(王道408考研操作系统)第三章内存管理-第一节5：动态分区分配算法（首次适应、和邻近适应）

(王道408考研操作系统)第三章内存管理-第一节6-1：非连续分配管理方式之基本分页存储管理

(王道408考研操作系统)第三章内存管理-第一节6-2：非连续分配管理方式之基本分页存储管理之基本地址变换机构

(王道408考研操作系统)第三章内存管理-第一节6-3：非连续分配管理方式之基本分页存储管理之具有快表的地址变换机构

(王道408考研操作系统)第三章内存管理-第一节6-4：非连续分配管理方式之基本分页存储管理之两级页表

(王道408考研操作系统)第三章内存管理-第一节7：非连续分配管理方式之基本分段管理方式

(王道408考研操作系统)第三章内存管理-第一节8：非连续分配管理方式之段页式管理方式

第二节：虚拟内存、请求分页及页面置换算法等

(王道408考研操作系统)第三章内存管理-第二节1：虚拟内存管理基本概念

(王道408考研操作系统)第三章内存管理-第二节2：请求分页管理方式

(王道408考研操作系统)第三章内存管理-第二节3：页面置换算法1

(王道408考研操作系统)第三章内存管理-第二节3：页面置换算法2

(王道408考研操作系统)第三章内存管理-第二节4：页面分配策略

第四章：文件管理

第一节：文件基本概念、目录、物理结构、逻辑结构、共享和安全等

(王道408考研操作系统)第四章文件管理-第一节1：文件管理初识

(王道408考研操作系统)第四章文件管理-第一节2：文件的逻辑结构

(王道408考研操作系统)第四章文件管理-第一节3：文件目录

(王道408考研操作系统)第四章文件管理-第一节4：文件物理结构（文件分配方式）

(王道408考研操作系统)第四章文件管理-第一节5：文件存储空间管理

(王道408考研操作系统)第四章文件管理-第一节6：文件基本操作

(王道408考研操作系统)第四章文件管理-第一节7：文件共享

(王道408考研操作系统)第四章文件管理-第一节8：文件保护

(王道408考研操作系统)第四章文件管理-第一节9：文件系统的层次结构

第二节：磁盘结构、磁盘调度算法等

(王道408考研操作系统)第四章文件管理-第二节1：磁盘的结构

(王道408考研操作系统)第四章文件管理-第二节2：磁盘调度算法

(王道408考研操作系统)第四章文件管理-第二节3：减少延迟时间的方法

(王道408考研操作系统)第四章文件管理-第二节4：磁盘的管理

第五章：输入/输出（I/O）管理

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节1：I/O设备的概念和分类

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节2：I/O控制器

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节3：I/O控制方式

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节4：I/O软件层次结构

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节5：假脱机(SPOOLing)技术

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节6：设备的分配和回收

(王道408考研操作系统)第五章输入/输出（I/O）管理-第一节7：缓冲区管理

四：Linux系统编程导航

用“哲学”来比喻操作系统我觉得再合适不过了。操作系统就是这样，你感觉你懂了其实你没有懂，你没有懂但是你又明白一点。所以想要落实唯一的一个方法就是实践、实践、实践。我们所学的操作系统并没有针对某个特定的操作系统，这里我选择的是Linux进行演示，因为它真的很直观

  • 所选用Linux系统为Centos 8.0

（1）第一部分：博客文章导航

Linux系统编程1：Linux中使用率最高的一些命令

Linux系统编程2：详解Linux中的权限问题

Linux系统编程3：基础篇之详解Linux软件包管理器yum

Linux系统编程4：入门篇之最强编辑器vim的使用攻略

Linux系统编程5：Linux系统编程5：入门篇之在Linux下观察C/C++程序编译过程 && gcc/g++使用详解

Linux系统编程7：入门篇之Linux项目自动化构建工具-Make/Makefile的超强使用指南

Linux系统编程9：进程入门之操作系统为什么这么重要以及它是如何实现管理的

Linux系统编程10：进程入门之系统编程中最重要的概念之进程&&进程的相关操作&&使用fork创建进程

Linux系统编程11：进程入门之详细阐述进程的一些状态&&区分僵尸状态和孤儿状态&&动图演示

Linux系统编程12：进程入门之进程的优先级及PR和NI&&如何修改进程优先级

Linux系统编程13：进程入门之Linux中的环境变量的概念及其相关命令（export；env等）&&main函数的参数

Linux系统编程14：进程入门之Linux进程中非常重要的概念之进程地址空间-原来我们看到的地址全部是虚拟的

Linux系统编程15：进程控制之如何创建进程和写时拷贝技术

Linux系统编程16：进程控制之进程终止以及终止进程的三种情况

Linux系统编程17：进程控制之进程等待&&为什么进程需要被等待&wait方法和waitpid方法&&阻塞和非阻塞等待

Linux系统编程18：超详解进程程序替换&exec函数的一些用法

Linux系统编程19：基础IO之了解Linux中的标准输入和输出以及相关的系统调用接口（如write，read等）

Linux系统编程20：基础IO之从内核代码深刻理解Linux是如何管理文件及文件描述符的本质是什么

Linux系统编程21：基础IO之全缓冲和行缓冲的区别及深刻理解缓冲区及其作用

Linux系统编程22：基础IO之掌握重定向的本质和使用dup2完成重定向

Linux系统编程23：基础IO之了解硬盘物理和逻辑结构及明白inode的本质和掌握软硬链接及其区别

Linux系统编程24：基础IO之在Linux下深刻理解C语言中的动静态库以及头文件和库的关系

Linux系统编程25：基础IO之亲自实现一个动静态库

Linux系统编程26：进程间通信之进程间通信的基本概念

Linux系统编程27：进程间通信之管道的基本概念和匿名管道与命名管道及管道特性

Linux系统编程28：进程间通信之共享内存和相关通信接口（ftok,shmget,shmctl,shmat,shmdt）

Linux系统编程29：进程信号之什么是信号及signal函数

Linux系统编程30：进程信号之产生信号的四种方式（Core Dump,kill,raise）

Linux系统编程31：进程信号之什么是信号的阻塞及相关术语（递达，未决，pending位图，handler位图）

Linux系统编程32：进程信号之详解信号集操作函数（sigset_t ,sigpending,sigprocmask）

Linux系统编程33：进程信号之详解信号的捕捉过程，用户态和内核态及其切换，sigaction和signal

Linux系统编程34：进程信号之可重入函数，volatile关键字的作用和SIGHLD

Linux系统编程35：多线程之如何理解Linux中的线程以及轻量级进程LWP

Linux系统编程36：多线程之线程控制之pthread线程库(线程创建，终止，等待和分离)

Linux系统编程37：多线程之什么是临界区和临界资源以及如何使用mutex互斥锁

Linux系统编程38：多线程之什么是线程同步以及条件变量函数

Linux系统编程39：多线程之基于阻塞队列生产者与消费者模型

Linux系统编程40：多线程之基于环形队列的生产者与消费者模型

Linux系统编程41：多线程之线程池的概念及实现

（2）第二部分：涉及的系统调用命令总结

A：进程部分

在这里插入图片描述

B：基础IO部分

在这里插入图片描述

C：进程间通信部分

在这里插入图片描述

D：进程信号部分

在这里插入图片描述

E：多线程部分

在这里插入图片描述

（3）第三部分：重要代码

1：理解fork的作用

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

int main()
{
	prinf("还没有执行fork函数的本进程为：%d\n",getpid());
	pid_t=fork();//其返回值是pid类型的
	sleep(1);
	
	if(ret>0)//父进程返回的是子进程ID
	{
		while(1)
		{
			printf("----------------------------------------------------------------\n");
			printf("我是父进程，我的id是：%d,我的孩子id是%d\n",getpid(),ret);
			sleep(1);
		}
	}
	else if(ret==0)//子进程fork返回值是0
	{
		while(1)
		{
			printf("我是子进程，我的id是%d，我的父亲id是%d\n",getpid(),getppid());
			sleep(1);
		}
	}
	else
		printf("进程创建失败\n");
		
	sleep(1);
	return 0;
}

2：理解僵尸状态

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
   // printf("还没执行fork函数时的本进程为：%d\n",getpid());
    pid_t ret=fork();//其返回值类型是pid_t型的
    sleep(1);
    if(ret>0)//父进程返回的是子进程ID
    {
      while(1)
      {
        printf("----------------------------------------------------\n");
        printf("父进程一直在运行\n");
        sleep(1);
      }
    }
    else if(ret==0)//子进程fork返回是0
    {
      int count=0;
      while(count<=10)
      {
        printf("子进程已经运行了%d秒\n",count+=1);
        sleep(1);
      }
      exit(0);//让子进程运行10s
    }
    else
      printf("进程创建失败\n");

    sleep(1);
    return 0;
}

3：理解进程等待及waitpid第二个参数

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t ret=fork();//其返回值类型是pid_t型的
    sleep(1);
    if(ret>0)//父进程返回的是子进程ID
    {
		printf("父进程正在等待子进程死亡\n");
		int st=0;
		pid_t rec=waitpid(ret,&st,0);//阻塞
		if(rec==ret)//如果返回值是子进程id，等待成功
		{
			printf("等待成功\n");
			if(WIFEXITED(st))//如果为真，正常退出
			{
				printf("正常退出且退出码为%d\n",WEXITSTATUS(st));
			}
			else
			{
				printf("异常退出，信号值为%d\n",st&0x7f);
			}
			
			
		}
		else
		{
			printf("等待失败\n");
			exit(0);
		}
	}
    else if(ret==0)//子进程fork返回是0
    {
      int count=1;
      while(count<=10)
      {
        printf("子进程[%d]已经运行了%d秒\n",getpid(),count);
		count++;
        sleep(1);
      }
      exit(3);
    }
    else
      printf("进程创建失败\n");

    sleep(1);
    return 0;
}

4：理解进程程序替换

//myprocess.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
  int count=0;
  while(count<5)
  {
    printf("Hello World\n");
    sleep(1);
    count++;
  }
  printf("%s\n",getenv("myenv"));
 return 0;
}

//test.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
  char* env[]={"myenv=you_can_see_this_env",NULL};
  printf("替换函数前\n");
  execle("./myprocess.exe","myprocess.exe",NULL,env);
  printf("替换函数后\n");

}

5：理解文件描述符

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

int main()
{
  int fd1=open("log1.txt",O_WRONLY);//打开错误
  int fd2=open("log2.txt",O_WRONLY|O_CREAT);//打开成功
  int fd3=open("log3.txt",O_WRONLY|O_CREAT);//打开成功
  int fd4=open("log4.txt",O_WRONLY|O_CREAT);//打开成功
  int fd5=open("log5.txt",O_WRONLY);//打开错误


  printf("%d\n",fd1);
  printf("%d\n",fd2);
  printf("%d\n",fd3);
  printf("%d\n",fd4);
  printf("%d\n",fd5);
}

6：理解匿名管道

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

int main()
{
  int  pipefd[2]={0};
   pipe(pipefd);
  pid_t id=fork();
  if(id==0)//child
  {
    close(pipefd[0]);
    const char* msg="This is the data that the child process wrote";
    while(1)
    {
        write(pipefd[1],msg,strlen(msg));
        sleep(1);
    }     
  }
  else//father
  {
    close(pipefd[1]);
    char buffer[64];
    while(1)
    {
        ssize_t ret=read(pipefd[0],buffer,sizeof(buffer)-1);
        if(ret>0)//判断是否读到
        {
            buffer[ret]='\0';//加上结束标志，便于输出
            printf("The father process got the information:%s\n",buffer);
        }
    }
  }
  return 0;
}

7：理解命名管道
server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
  umask(0);//屏蔽命令行umask干扰
  if(mkfifo("./fifo",0666)==-1)//如果mkfifo返回值是-1，创建失败
  {
    perror("打开失败");
    return 1;
  }
  int fd=open("fifo",O_RDONLY);//服务端以只读的方式打开管道文件
  if(fd>=0)
  {
    char buffer[64];
    while(1)
    {
      printf("客户端正在接受消息\n");
      printf("############################\n");
      ssize_t ret=read(fd,buffer,sizeof(buffer)-1);
      if(ret>0)
      {
          buffer[ret]='\0';
          printf("服务端接受到客户端消息：%s\n",buffer);
      }
      else if(ret==0)//如果客户端退出，将会读到文件结束，所以服务端也要退出
      {
          printf("客户端已经下线，服务端下线\n");
          break;
      }
      else 
      {
        perror("读取失败\n");
        break;
      }
    }
  }
}

client.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int main()
{
  int fd=open("fifo",O_WRONLY);//直接打开管道文件
  if(fd>=0)
  { 
      char buffer[64];//从键盘读入数据到这个缓冲区
      while(1)
      { 
          printf("客户端-请输入消息：");
          ssize_t ret=read(0,buffer,sizeof(buffer)-1);//从键盘读入数据
          if(ret>0)
          { 
              buffer[ret]='\0';
              write(fd,buffer,ret);//读入ret个数据就向管道中写入ret个数据
          }
      }
  }
}

8:理解共享内存
server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <sys/shm.h>

#define PATHNAME "tmp"
#define PROJ_ID 88
#define  SIZE 4096

int main()
{
  key_t k=ftok(PATHNAME,PROJ_ID);
  printf("key值：%#X\n",k);

  int shmid=shmget(k,SIZE,IPC_CREAT | IPC_EXCL|0666);
  if(shmid<0)
  {
    perror("creat failed");
    return 1;
  }
  char* shmaddr=shmat(shmid,NULL,0);//挂接,注意强转
  while(1)//每1s打印一次
  {
      sleep(1);
      printf("%s\n",shmaddr);
  }

  shmdt(shmaddr);//脱离
  shmctl(shmid,IPC_RMID,NULL);//释放
 
  return 0；
}

client.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <sys/shm.h>

#define PATHNAME "tmp"
#define PROJ_ID 88
#define  SIZE 4096

int main()
{
  key_t k=ftok(PATHNAME,PROJ_ID);
  printf("key值：%#X\n",k);

  int shmid=shmget(k,SIZE,0);//服务端已经申请了，写成0直接获取
  if(shmid<0)
  {
    perror("creat failed");
    return 1;
  }
  char* shmaddr=shmat(shmid,NULL,0);//挂接，注意强转
  int i=0;
  while(i<26)
  {
    shmaddr[i]=97+i;每隔5s依次输入a,b,c...........................
    i++;
    sleep(5);

  }
  shmdt(shmaddr);//脱离
  return 0;
}

9：理解signal函数

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

void handler(int sig)
{
  printf("catch a sin : %d\n",sig);

}

int main()
{
  signal(2,handler);//一旦捕捉到2号信号，将会执行handler函数内的操作
  while(1)
  {
    printf("I Am runnng now...\n");
    sleep(1);
  }
  return 0;

}

10：理解信号集操作函数

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

void handler(int sig)
{
  printf("获得信号:%d\n",sig);

}

void print_pending(sigset_t* pending)
{
  int i=1;
  for(i=1;i<=31;i++)
  {
    if(sigismember(pending,i))
    {
      printf("1");//只要i信号存在，就打印1
    }
    else 
    {
      printf("0");//不存在这个信号就打印0
    }
  }
  printf("\n");
}

int main()
{
  signal(2,handler);//捕捉

  sigset_t pending;//定义信号集变量

  sigset_t block,oblock;//定义阻塞信号集变量
  sigemptyset(&block);
  sigemptyset(&oblock);//初始化阻塞信号集

  sigaddset(&block,2);//将2号信号添加的信号集

  sigprocmask(SIG_SETMASK,&block,&oblock);//设置屏蔽关键字

  int cout=0; 
  while(1)
  {
    sigemptyset(&pending);//初始化信号集
    sigpending(&pending);//读取未决信号集，传入pending
    print_pending(&pending);//定义一个函数，打印未决信号集
    sleep(1);
    cout++;
    if(cout==10)//10s后解除阻塞
    {
      printf("解除阻塞\n");
      sigprocmask(SIG_SETMASK,&oblock,NULL);
    }

  }
}

11：理解线程的创建，等待等

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


void* new_thread(void* arg)
{
  while(1)
  {
    printf("我是新线程，我的线程id是%p\n",pthread_self());
    sleep(5);
    int a=1/0; //浮点异常
  }
}

int main()
{
  pthread_t tid;//线程的ID
  pthread_create(&tid,NULL,new_thread,(void*)"我是新线程");
  while(1)
  { 
    printf("-----------------------------------------------------------\n");
    printf("我是主线程，我的线程id是:%p，新线程的id是%p\n",pthread_self(),tid);
    void* ret;//获取退出码
    pthread_join(tid,&ret);
    printf("主线程阻塞等待新线程，退出码码为%d\n",(int)ret);
    break;
  }


}

12：理解互斥锁

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


int tickets=1000;

pthread_mutex_t lock;//申请一把锁

void scarmble_tickets(void* arg)
{
  long int ID=(long int)arg;//线程ID
  while(1)//多个线程循环抢票
  {
    pthread_mutex_lock(&lock);//那个线程先到，谁就先锁定资源
    if(tickets>0)
    {
      usleep(1000);
      printf("线程%ld号抢到了一张票，现在还有%d张票\n",ID,tickets);
      tickets--;
      pthread_mutex_unlock(&lock);//抢到票就解放资源
    }
    else 
    {
      pthread_mutex_unlock(&lock);//如果没有抢到也要释放资源，否则线程直接退出，其他线程无法加锁
      break;
    }
  }

}


int main()
{
  int i=0;
  pthread_t tid[4];//4个线程ID
  pthread_mutex_init(&lock,NULL);//初始化锁
  for(i=0;i<4;i++)
  {
    pthread_create(tid+1,NULL,scarmble_tickets,(void*)i);//创建4个线程
  }

  for(i=0;i<4;i++)
  {
    pthread_join(tid+1,NULL);//线程等待
  }
  pthread_mutex_destroy(&lock);//销毁锁资源
  return 0;
}

13：理解条件变量

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

pthread_mutex_t lock;//锁
pthread_cond_t cond;//条件

void* thread_a(void* arg)//其他线程被唤醒
{
  const char* name=(char*)arg;//线程名字
  while(1)
  {
    pthread_cond_wait(&cond,&lock);//一直在等待条件成熟
    printf("%s被唤醒了\n=================================================\n",name);

  }

}

void* thread_1(void* arg)//让线程1唤醒其他线程
{
  const char* name=(char*)arg;
  while(1)
  {
    sleep(rand()%5+1);//随机1-5秒唤醒
    pthread_cond_signal(&cond);
    printf("%s现在正在发送信号\n",name);
  }

}



int main()
{
  pthread_mutex_init(&lock,NULL);//初始化锁
  pthread_cond_init(&cond,NULL);//初始化条件

  pthread_t t1,t2,t3,t4,t5;//创建两个线程
  pthread_create(&t1,NULL,thread_1,(void*)"线程1"); 

  pthread_create(&t2,NULL,thread_a,(void*)"线程2"); 
  pthread_create(&t3,NULL,thread_a,(void*)"线程3"); 
  pthread_create(&t4,NULL,thread_a,(void*)"线程4"); 
  pthread_create(&t5,NULL,thread_a,(void*)"线程5"); 

  pthread_join(t1,NULL);
  pthread_join(t2,NULL);
  pthread_join(t3,NULL);
  pthread_join(t4,NULL);
  pthread_join(t5,NULL);

  pthread_mutex_destroy(&lock);
  pthread_cond_destroy(&cond);//销毁条件

}

五：Linux命令行大全导航

多数情况下，我们使用Linux系统时都会用命令行而不使用图形界面，因为Linux多作远程服务器开发，所以图形界面不方便。因此这里为了让大家能够快速掌握Linux中的一些常用命令，特向大家推荐 《Linux命令行大全》 这本书，并且已做笔记导航如下

第1章：shell是什么

第2章：导航

第3章：Linux系统

第4章：操作文件与目录

第5章：命令的使用

第6章：重定向

第7章：透过shell看世界

第8章：高级键盘技巧

第9章：权限

第10章：进程

第11章：环境

第12章：Vim编辑器

第13章：定制shell提示符

第14章：软件包管理

第15章：存储介质

第16章：网络

第17章：文件搜索

第18章：归档和备份

第19章：正则表达式

第19章：文本处理

第20章：格式化输出

第21章：shell脚本

快乐江湖
关注
  • 44
    点赞
  • 踩
  • 541
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
订阅专栏
王道考研 操作系统知识点汇总(目录+思维导图)
张时贰的博客
01-19 5534
第一章 计算机系统概述 文章目录前言1.1.1 操作系统的概念、功能和目标思维导图本节内容1.1.2操作系统的特征思维导图本节内容1.1.3操作系统的发展与分类思维导图本节内容1.1.4操作系统的运行机制与体系结构思维导图本节内容1.运行机制两种指令两种处理器状态2.操作系统的内核1.1.5中断和异常思维导图本节内容1.1.6系统调用思维导图本节内容2.1.1进程的定义、组成、组织方式思维导图本节内容2.1.2进程的状态与转换思维导图本节内容2.1.3进程控制思维导图本节内容2.1.4进程通信思维导图本节内
操作系统题库 操作系统题库
08-16
操作系统 操作系统 题库 操作系统 操作系统 题库
【408】操作系统（王道考研）
m0_51634403的博客
03-12 581
本文章基于王道考研视频进行总结的操作系统笔记
【计算机考研】408只看王道四本书够吗？
cherry30的博客
05-31 1733
408涵盖了四大核心课程， 建议的学习顺序为：数据结构、计算机组成原理、操作系统、计算机网络。
操作系统学习——王道考研（完）
Mostan727的博客
11-21 915
操作系统是系统资源的管理者，操作系统(OS)是控制和管理整个计算机系统的硬件和软件资源，并合理的组织调度计算机工作和资源的分配，以提供用户和其他软件方便的接口和环境，是计算机系统中基本的系统软件。多道程序环境下，允许多个程序并发执行，但由于资源有限，进程的执行不是一贯到底，而是走走停停，不可预知的速度向前推进，这就是进程的异步性。由于并发运行的程序会争抢着使用系统资源，因此进程的执行不是一贯到底的，而是走走停停的，一不可预知的速度推进。：系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问。
考研王道操作系统重点习题.rar
12-23
这个是汇总的王道操作系统上面的部分易错习题，适合考研的同学，是本人用手机扫描下来的，一道题一道答案，介意勿下。
王道考研 操作系统学习笔记：
py431382的博客
05-21 1491
王道考研 操作系统学习笔记（复习用）： 课程链接：https://www.bilibili.com/video/BV1YE411D7nH 1.1.1： 介绍操作系统的定义，可理解为软硬件中间层，管理处理机、存储器、文件、设备四大资源。 1.1.2： 操作系统（os）的特征：并发、共享、虚拟、异步；前两点是后两点的基础 1.1.3： 回顾os发展并给出分类：手工、批处理、分时、实时、网络、分布式、个人计算机 1.1.4： os运行机制和体系结构：指令特权与否，cpu核心态用户态，程序内外之分；时钟，中断，原语
操作系统笔记（王道考研） 第一章：计算机系统概述
zimuzi2019的博客
08-16 4375
操作系统笔记（王道考研） 第一章：计算机系统概述
【王道考研-操作系统】操作系统概述（学习笔记）
wmh的博客
12-06 2258
操作系统：指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计算机的工作和资源的分配以提供给用户和其他软件方便的接口和环境是计算机系统中最基本的系统软件提供的功能：处理机管理、存储器管理、文件管理、设备管理1. 直接服务用户GUI：图形用户解密命令接口：联机命令接口 = 交互式命令接口（有问有答）脱机命令接口 = 批处理命令接口（用户说，系统做）2. 服务软件程序接口：可以在程序中进行系统调用来使用程序接口。普通用户不能直接使用程序接口，只能通过程序代码间接使用（系统调用=广义指令）没有任何软件支
操作系统-王道笔记 (详细)
donkey010的博客
01-28 6206
第一章：计算机系统概述 知识框架 1.1 操作系统管理 1.1.1 操作系统的概念 操作系统 (Operating System, OS) 是指控制和管理整个计算机系统的硬件与软件资源，合理地组织、调度计算机的工作与资源的分配，进而为用户和其他软件提供方便接口与环境的程序集合。 操作系统是计算机系统中最基本的系统软件。 1.1.2 操作系统的特征 操作系统的基本特征包括并发、共享、虚拟和异步。 井发和共享是操作系统两个最基本的特征，这两者之间又是互为存在条件的： ①资源共享是以程序的并发为条件的，若系
JavaWeb每日总结思维导图
05-22
JavaWeb每日总结思维导图，包含JavaWeb开发的多项技术，方便复习知识点使用。内容包括：MySQL、MySQL约束&多表、MySQL多表&事务、JDBC、数据库连接池、HTML、CSS、JS基础&高级、BootStrap、XML、Tomcat、Servlet&...
Linux黄金时代——IBM中国Linux解决方案中心系列专栏：北京市商业银行综合业务系统解决方案.pdf
09-07
《Linux黄金时代——IBM中国Linux解决方案中心系列专栏：北京市商业银行综合业务系统解决方案》这篇文档讲述了在银行业务系统中，如何利用Linux操作系统进行系统整合和优化，以提高系统的可靠性、稳定性和维护效率。...
jsp+sql操作系统教学网站设计(lw+程序).zip
最新发布
06-05
通过操作系统教学网站的建设，完成了对于操作系统课程的远程化授课。可以使学生不受时间空间的限制，通过网络对于这门课程进行学习。建立起了基于B/C的网络化教学系统。本网站采用当前最流行的JSP网络编程技术，可以...
jsp+sql操作系统教学网站设计(程序)
05-30
通过操作系统教学网站的建设，完成了对于操作系统课程的远程化授课。可以使学生不受时间空间的限制，通过网络对于这门课程进行学习。建立起了基于B/C的网络化教学系统。本网站采用当前最流行的JSP网络编程技术，可以...
操作系统考研——计算机系统概述
qq_43983010的博客
03-09 1117
计算机系统概述一、操作系统的基本概念1.操作系统概念2.操作系统特征a.并发b.共享c.虚拟d.异步3.操作系统目标和功能a.管理功能（1）处理机管理（2）存储器管理（3）文件管理（4）设备管理b.接口功能（1）命令接口（2）程序接口c.扩充机器二、操作系统的发展和分类1.手工操作阶段2.批处理阶段3.分时系统4.实时系统5.分布式计算机系统6.个人计算机操作系统三、操作系统的运行环境1.操作系统的运行机制2.中断与异常3.用户态与内核态四、大内核与微内核 一、操作系统的基本概念 1.操作系统概念 &n
王道考研操作系统笔记
weixin_45558998的博客
08-30 361
2.1.1： 进程介绍：理解为系统资源分配和调度的一个单位。os用PCB记录管理进程信息。 2.1.2： 进程状态：创建、就绪、运行、阻塞、终止，以及其转换关系。 2.1.3： 进程控制：用不可中断的原语来操作。 2.1.4： 进程通信：共享存储、管道通信、消息传递；前两者注意互斥访问； 2.1.5： 线程：系统处理机调度的单位，注意比较进程；线程有内核级、用户级的区别；多线程模型有多对一、一对一、多对多之分（指用户线程对内核线程）。 2.2.1： 处理机调度层次：高级（作业）、中级（内存）、低
王道计算机考研操作系统笔记（全）
m0_53221050的博客
08-09 234
笔者在简要学习操作系统时所做的笔记，主要是观看王道计算机考研操作系统的教学视频。如果需要MarkDown文件、课程PPT的话可以私信。
408计算机考研笔记（王道考研）：操作系统 第三章 内存管理
阿宾爱干饭
02-26 908
操作系统第三章内存管理内容
操作系统——bilibili王道考研操作系统课程笔记
margaret522的博客
02-24 3229
知识总览 1.1.1操作系统的概念（定义） 计算机系统的层次结构：逻辑（纯硬件）->操作系统->应用程序-》用户。 操作系统： 1.负责管理协调硬件、软件等计算机资源的工作。 2.为上层的应用程序、用户 提供简单易用的服务。 3.操作系统是系统软件，而不是硬件。 ...
计算机操作系统怎么学
04-10
计算机操作系统是计算机系统中最基础、最核心的软件之一，它负责管理和控制计算机的硬件资源，并提供给应用程序一个简单、一致的接口。学习计算机操作系统可以帮助你深入理解计算机系统的工作原理和内部机制。 以下是学习计算机操作系统的一些建议步骤： 1. 基础知识：首先，你需要了解计算机体系结构和计算机组成原理的基础知识，包括处理器、内存、输入输出设备等。这将帮助你理解操作系统与硬件之间的交互。 2. 操作系统概念：学习操作系统的基本概念，包括进程管理、内存管理、文件系统、设备管理等。了解这些概念可以帮助你理解操作系统的功能和作用。 3. 学习经典教材：选择一本经典的操作系统教材进行学习，比如《操作系统概念》(Operating System Concepts)、《现代操作系统》(Modern Operating Systems)等。这些教材通常会详细介绍操作系统的原理、设计和实现。 4. 实践项目：通过实践项目来加深对操作系统的理解。可以尝试实现一个简单的操作系统或者参与开源操作系统项目的开发。这样可以帮助你更深入地理解操作系统的内部机制。 5. 学习资源：除了教材，还可以参考一些在线资源和教学视频，如操作系统的MOOC课程、学术论文等。这些资源可以帮助你更全面地了解操作系统的最新研究和发展动态。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐江湖

创作不易，感谢支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值