[关闭]
@3013216027 2016-01-28T05:18:05.000000Z 字数 8867 阅读 1998

操作系统原理

os2015

  1. enter_regine:
  2.     move register, 1H
  3.     xchg register, lock
  4.     cmp register, 0H
  5.     jnz enter_regine
  6.     ret
  7. leave_regine:
  8.     move lock, 0H
  9.     ret

0. Linux

类型 可转义字符
单引号 硬转义，内部所有通配符和shell元字符均被关闭
双引号 软转义，内部可以使用$和`
反斜线\ 转义，能且仅能转义后面紧跟的一个字符
参数 功能
-a, -o 逻辑与，或
(直接字符串) 或-n, -z, =, != 字符串长度非0，为0，相等，不等
-ge, -gt, -eq, -ne, -lt, le 整数≥，＞，＝，≠，＜，≤
-d, -e, -s, -r, -w, -x 文件为目录，存在，非空，可读，可写，可执行

1. 进程

1.1 进程

  1. semaphore count_mutex = 1; /* 读者计数器互斥访问 */
  2. semaphore db_mutex = 1; /* 数据库互斥访问 */
  3. int count = 0; /* 读者计数 */
  5. void
  6. reader()
  7. {
  8.     /* enter */
  9.     P(count_mutex);
  10.     if (count == 0) P(db_mutex);
  11.     count = count + 1;
  12.     V(count_mutex);
  14.     read_data();
  16.     /* leave */
  17.     P(count_mutex);
  18.     count = count - 1;
  19.     if (count == 0) V(db_mutex);
  20.     V(count_mutex);
  21. }
  23. void
  24. writer()
  25. {
  26.     /* enter */
  27.     P(db_mutex);
  29.     write_data();
  31.     /* leave */
  32.     V(db_mutex);
  33. }
  1. semaphore db_mutex = 1; /* 数据库互斥访问 */
  2. semaphore creader_mutex = 1; /* 读者计数器互斥访问 */
  3. semaphore readable = 1; /* 可读信号量 */
  4. int creader = 0;
  6. void
  7. reader()
  8. {
  9.     /* enter */
  10.     P(readable);
  11.     P(creader_mutex);
  12.     if (creader == 0) P(db_mutex);
  13.     creader = creader + 1;
  14.     V(creader_mutex);
  15.     V(readable);
  17.     read_data();
  19.     /* leave */
  20.     P(creader_mutex);
  21.     creader = creader - 1;
  22.     if (creader == 0) V(db_mutex);
  23.     V(creader_mutex);
  24. }
  26. void
  27. writer()
  28. {
  29.     P(write_mutex);
  30.     P(mutex);
  32.     read_data();
  34.     V(mutex);
  35.     V(write_mutex);
  36. }
  1. semaphore creader_mutex = 1;
  2. semaphore cwriter_mutex = 1;
  3. semaphore reading = 1;
  4. semaphore writing = 1;
  5. int creader = 0;
  6. int cwriter = 0;
  8. void
  9. reader()
  10. {
  11.     P(reading);
  12.     P(creader_mutex);
  13.     if (creader == 0) P(writing);
  14.     creader = creader + 1;
  15.     V(creader_mutex);
  16.     V(reading);
  18.     read_data();
  20.     P(creader_mutex);
  21.     creader = creader - 1;
  22.     if (creader == 0) V(writing);
  23.     V(creader_mutex);
  24. }
  26. void
  27. writer()
  28. {
  29.     P(cwriter_mutex);
  30.     if (cwriter == 0) P(reading);
  31.     cwriter = cwriter + 1;
  32.     V(cwriter_mutex);
  34.     P(writing);
  35.     write_data();
  36.     V(writing);
  38.     P(cwriter_mutex);
  39.     cwriter = cwriter - 1;
  40.     if (cwriter == 0) V(reading);
  41.     V(cwriter_mutex);
  42. }

1.2 线程

  1. #include <stdio.h>
  2. #include <pthread.h>
  3. #include <stdlib.h>
  5. #define MAX 10
  7. void* say_hello(void* tid) {
  8.     printf("hello from %d\n", *(int*)tid);
  9.     pthread_exit(NULL);
  10.     return NULL;
  11. }
  13. int main() {
  14.     pthread_t threads[MAX];
  15.     int ids[MAX];
  16.     int status, i;
  18.     for (i = 0; i < MAX; ++i) {
  19.         printf("Create thread %d\n", i);
  20.         ids[i] = i;
  21.         status = pthread_create(threads + i, NULL, say_hello, (void*)(ids + i));
  22.         if (status != 0) {
  23.             printf("error occur when create thread, with ret %d\n", status);
  24.             exit(-1);
  25.         }
  26.     }
  27.     return 0;
  28. }

1.3 调度

1.4 死锁

条件 预防方法
互斥 统一使用假脱机
占有和等待 在开始就请求全部资源
不可抢占 抢占资源
环路等待 资源按序访问



2. 内存

2.4 页面置换算法

3. 存储

3.1 LVM(Logical Volumn Manager)简说

3.2 RAID简说

磁臂移动算法

4. 设备

课件内容

  1. 简介
  2. 进程-进程
  3. 进程-线程
  4. 进程-调度
  5. 进程-竞争条件
  6. 进程-IPC

  7. 进程-死锁

  8. 内存-概览

  9. 内存-虚拟内存
  10. 内存-分段

  11. 内存-页面置换

  12. Intel-x86

  13. 存储-文件
  14. 存储-文件系统

  15. 存储-存储

  16. 设备-设备

  17. Linux
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注