《操作系统导论》学习笔记（一）：操作系统概览

概览

操作系统导论从虚拟性、并发性和持续性等3个设计操作系统的本质出发，并将传统操作系统的进程管理、内存管理、文件管理、I/O管理贯穿其中。

	虚拟性	并发性	持续性
进程管理	进程，CPU调度	线程，死锁，进程同步
内存管理	内存管理
存储管理	I/O系统		文件系统，大型存储器

为什么需要操作系统？

在这里插入图片描述
计算机系统从下至上大致可分为计算机硬件、操作系统、系统和应用软件。用户工作在软件层，使用Word、Matlab等软件完成自己的目的，而从硬件的角度，计算机仅是CPU取指令(fetch)、译码(decode)、执行(execute)的过程。那么如何合理地将应用软件与硬件衔接起来，这就需要引入操作系统软件作为两者的接口。
在这里插入图片描述
操作系统软件的本质是无限循环的程序，开机以后便不断接受用户指令，直到强制关机才结束程序运行。基于macOS、linux等系统，并下载common.h等头文件，我们可模拟操作系统运行过程：

// cpu.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <assert.h>
#include "common.h"

int main(int argc, char *argv[])  // argc 命令行参数个数
{								  // argv 命令行参数向量
  if (argc != 2) {
    fprintf(stderr, "usage: cpu <string>\n");
    exit(1);
  }

  char *str = argv[1];
  while (1) {
    Spin(1);
    printf("%s\n", str);
  }

  return 0;
}

Spin()函数:位于common.h，使程序输出间隔一段时间
gcc -o 执行文件名源文件名：编译源文件
Wall：编译后显示所有警告
Werror：将所有的警告当成错误进行处理
在这里插入图片描述
执行命令hello，我们可以发现该程序会不停输出hello，直至强制结束程序。

多输入几条命令，该程序会同时输出3条命令，从而使用户产生有多个CPU在同时执行命令的错觉(illusion)，这就是CPU的虚拟化。

虚拟化(virtualization)

虚拟化是把一个物理上的实体映射为若干个逻辑上的对应物，实现方法有时分复用及空分复用。我们可模拟内存虚拟化，并通过getpid()获取进程号，指针p更新数据并获取数据存储地址。

// mem.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"

int main(int argc, char *argv[])
{
  if (argc != 2) {
    fprintf(stderr, "usage: mem <value>\n");
    exit(1);
  }
  
  int *p = malloc(sizeof(int));
  assert(p != NULL);                         // getpid() 进程识别码   p 指向内存的指针
  printf("(pid:%d) addr of p:        %llx\n", (int)getpid(), (unsigned long long)p);
  printf("(pid:%d) addr stored in p: %llx\n", (int)getpid(), (unsigned long long)p);
  
  *p = atoi(argv[1]); // assign value to addr stored in p
  while (1) {
    Spin(1);
    *p = *p + 1;
    printf("(pid:%d) p: %d\n", getpid(), *p);
  }
 
  return 0;
}

在这里插入图片描述

此时我的机器上执行两个进程，进程号为11984和11985，存储地址为7fbf56c01720及7fb86cc01720，分别从1000和2000开始每次自增1。

并发性(concurrence)

并发性是宏观上同一时间间隔内运行多个进程，操作系统通过引入进程及线程实现。

// threads.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "common.h"

volatile int counter = 0;  // 本条指令不会因编译器的优化而省略，且要求每次直接读值。
int loops;

void *worker(void *arg) {  // 计数器
  int i;
  for (i = 0; i < loops; i++) {
    counter++;
  }
  return NULL;
}

int main(int argc, char *argv[]) {
  if (argc != 2) {
    fprintf(stderr, "usage: threads <value>\n");
    exit(1);
  }

  loops = atoi(argv[1]);
  pthread_t p1, p2;		// 声明线程id
  printf("Initial value : %d\n", counter);

  pthread_create(&p1, NULL, worker, NULL);
  pthread_create(&p2, NULL, worker, NULL);
  pthread_join(p1, NULL);
  pthread_join(p2, NULL);
  printf("Final value   : %d\n", counter);
  return 0;
}

pthread_create():创建线程，运行相关的线程函数。
第一个参数为指向线程标识符的指针。
第二个参数用来设置线程属性。
第三个参数是线程运行函数的起始地址。
最后一个参数是运行函数的参数。

pthread_join():阻塞当前线程/回收线程资源
第一个参数线程标识符
第二个参数用户定义的指针，用来存储被等待线程的返回值。
在这里插入图片描述
程序创建两个线程执行计数器worker()函数，初值为0，参数loops为1000，结果为2000。但当参数较大时，可能结果小于期望值的情况。这是因为两个计数器线程共享同一个counter，两个线程可能会同时取counter并执行。解决方法就是给counter上锁，即PV操作。

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;    // 全局信号量初始化
void *worker(void *arg) {
  int i;
  for (i = 0; i < loops; i++) {
    pthread_mutex_lock(&m);		// 上锁
    counter++;
    pthread_mutex_unlock(&m);	// 开锁
  }
  printf("%d\n", counter);
  pthread_exit(NULL);
}

在这里插入图片描述

持久化(persistence)

持久化是将瞬时的数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。

// io.c
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>

void dowork()
{
  int fd = open("/tmp/file", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
  assert(fd >= 0);
  
  char buffer[20];
  sprintf(buffer, "hello world\n");
  int rc = write(fd, buffer, strlen(buffer));
  assert(rc == (strlen(buffer)));
  printf("wrote %d bytes\n", rc);
  
  fsync(fd);
  close(fd);
}
int main(int argc, char *argv[]) {
  dowork();
  return 0;
}