分类目录归档:操作系统

操作系统解析

操作系统解析

操作系统(operating system)是管理计算机硬件与软件资源的计算机程序,同时也是计算机系统的内核与基石。操作系统需要处理如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。操作系统也提供一个让用户与系统交互的操作界面。

操作系统的类型非常多样,不同机器安装的操作系统可从简单到复杂,可从移动电话的嵌入式系统到超级计算机的大型操作系统。许多操作系统制造者对它涵盖范畴的定义也不尽一致,例如有些操作系统集成了图形用户界面,而有些仅使用命令行界面,而将图形用户界面视为一种非必要的应用程序。

操作系统基本特征

  1. 并发和并行

并发是指宏观上在一段时间内能同时运行多个程序,而并行则指同一时刻能运行多个指令。
并行需要硬件支持,如多流水线或者多处理器。

操作系统通过引入进程和线程,使得程序能够并发运行。

  1. 共享

共享是指系统中的资源可以被多个并发进程共同使用。

有两种共享方式:互斥共享和同时共享。

互斥共享的资源称为临界资源,例如打印机等,在同一时间只允许一个进程访问,需要用同步机制来实现对临界资源的访问。

  1. 虚拟

虚拟技术把一个物理实体转换为多个逻辑实体。

利用多道程序设计技术,让每个用户都觉得有一个计算机专门为他服务。

主要有两种虚拟技术:时分复用技术和空分复用技术。例如多个进程能在同一个处理器上并发执行使用了时分复用技术,让每个进程轮流占有处理器,每次只执行一小个时间片并快速切换。

  1. 异步

异步指进程不是一次性执行完毕,而是走走停停,以不可知的速度向前推进。

但只要运行环境相同,OS需要保证程序运行的结果也要相同。

操作系统基本功能

  1. 进程管理

进程控制、进程同步、进程通信、死锁处理、处理机调度等。

  1. 内存管理

内存分配、地址映射、内存保护与共享、虚拟内存等。

  1. 文件管理

文件存储空间的管理、目录管理、文件读写管理和保护等。

  1. 设备管理

完成用户的 I/O 请求,方便用户使用各种设备,并提高设备的利用率。

主要包括缓冲管理、设备分配、设备处理、虛拟设备等。

系统调用

如果一个进程在用户态需要使用内核态的功能,就进行系统调用从而陷入内核,由操作系统代为完成。

Linux 的系统调用主要有以下这些:

Task Commands
进程控制 fork(); exit(); wait();
进程通信 pipe(); shmget(); mmap();
文件操作 open(); read(); write();
设备操作 ioctl(); read(); write();
信息维护 getpid(); alarm(); sleep();
安全 chmod(); umask(); chown();

大内核和微内核

  • 大内核

大内核是将操作系统功能作为一个紧密结合的整体放到内核。

由于各模块共享信息,因此有很高的性能。

  • 微内核

由于操作系统不断复杂,因此将一部分操作系统功能移出内核,从而降低内核的复杂性。移出的部分根据分层的原则划分成若干服务,相互独立。

在微内核结构下,操作系统被划分成小的、定义良好的模块,只有微内核这一个模块运行在内核态,其余模块运行在用户态。

因为需要频繁地在用户态和核心态之间进行切换,所以会有一定的性能损失。

中断分类

  1. 外中断

由 CPU 执行指令以外的事件引起,如 I/O 完成中断,表示设备输入/输出处理已经完成,处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。

  1. 异常

由 CPU 执行指令的内部事件引起,如非法操作码、地址越界、算术溢出等。

  1. 陷入

在用户程序中使用系统调用。

类型 源头 响应方式 处理机制
中断 外设 异步 持续,对用户应用程序是透明的
异常 应用程序意想不到的行为 同步 杀死或重新执行意想不到的应用程序指令
系统调用 应用程序请求操作提供服务 异步或同步 等待和持续
  1. 什么是堆和栈?说一下堆栈都存储哪些数据?

栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。

堆区(heap) — 一般由程序员分配释放, 若开发者不释放,则会在程序结束时可能由OS回收 。

数据结构中这两个完全就不放一块来讲,数据结构中栈和队列才是好基友,我想新手也很容易区分。

我想需要区分的情况肯定不是在数据结构话题下,而大多是在 OS 关于不同对象的内存分配这块上。

简单讲的话,在 C 语言中:

int a[N];   // go on a stack
int* a = (int *)malloc(sizeof(int) * N);  // go on a heap

  1. 分布式锁

分布式锁,是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中,常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源,那么访问这些资源的时候,往往需要互斥来防止彼此干扰来保证一致性,在这种情况下,便需要使用到分布式锁。

进程管理

进程与线程:

  1. 进程

进程是资源分配的基本单位,用来管理资源(例如:内存,文件,网络等资源)

进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态,所谓的创建进程和撤销进程,都是指对 PCB 的操作。(PCB是描述进程的数据结构)

上面是4 个程序创建了 4 个进程,这 4 个进程可以并发地执行。

  1. 线程

线程是独立调度的基本单位。

一个进程中可以有多个线程,它们共享进程资源。

QQ 和浏览器是两个进程,浏览器进程里面有很多线程,例如 HTTP 请求线程、事件响应线程、渲染线程等等,线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时,浏览器还可以响应用户的其它事件。

  1. 区别

(一)拥有资源

进程是资源分配的基本单位,但是线程不拥有资源,线程可以访问隶属进程的资源。

(二)调度

线程是独立调度的基本单位,在同一进程中,线程的切换不会引起进程切换,从一个进程内的线程切换到另一个进程中的线程时,会引起进程切换。

(三)系统开销

由于创建或撤销进程时,系统都要为之分配或回收资源,如内存空间、I/O 设备等,所付出的开销远大于创建或撤销线程时的开销。类似地,在进行进程切换时,涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置,而线程切换时只需保存和设置少量寄存器内容,开销很小。

(四)通信方面

进程间通信 (IPC) 需要进程同步和互斥手段的辅助,以保证数据的一致性。而线程间可以通过直接读/写同一进程中的数据段(如全局变量)来进行通信。

进程状态的切换

就绪状态(ready):等待被调度
运行状态(running)
阻塞状态(waiting):等待资源

需要注意的是:

  • 只有就绪态和运行态可以相互转换,其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间,转为运行状态;而运行状态的进程,在分配给它的 CPU 时间片用完之后就会转为就绪状态,等待下一次调度。

  • 阻塞状态是缺少需要的资源从而由运行状态转换而来,但是该资源不包括 CPU 时间,缺少 CPU 时间会从运行态转换为就绪态。

  • 进程只能自己阻塞自己,因为只有进程自身才知道何时需要等待某种事件的发生

进程调度算法

相信很多人都听说过进程调度的算法,但是不同环境的调度算法目标不同,因此需要针对不同环境来讨论调度算法。

  1. 批处理系统

批处理系统没有太多的用户操作,在该系统中,调度算法目标是保证吞吐量和周转时间(从提交到终止的时间)。

  • 先来先服务
    先来先服务 first-come first-serverd(FCFS),按照请求的顺序进行调度。这样可以有利于长作业,但不利于短作业,因为短作业必须一直等待前面的长作业执行完毕才能执行,而长作业又需要执行很长时间,造成了短作业等待时间过长。

  • 短作业优先

短作业优先 shortest job first(SJF),按估计运行时间最短的顺序进行调度。长作业有可能会饿死,处于一直等待短作业执行完毕的状态。因为如果一直有短作业到来,那么长作业永远得不到调度。

  • 最短剩余时间优先

最短剩余时间优先 shortest remaining time next(SRTN),按估计剩余时间最短的顺序进行调度。

  1. 交互式系统

交互式系统有大量的用户交互操作,在该系统中调度算法的目标是快速地进行响应。

  • 时间片轮转算法
    将所有进程按FCFS (先来先服务) 的原则排成一个队列,每次调度时,把 CPU 时间分配给队首进程,该进程可以执行一个时间片。当时间片用完时,由计时器发出时钟中断,调度程序便停止该进程的执行,并将它送往就绪队列的末尾,同时继续把 CPU 时间分配给队首的进程。

时间片轮转算法的效率和时间片的大小有很大关系。因为进程切换都要保存进程的信息并且载入新进程的信息,如果时间片太小,会导致进程切换得太频繁,在进程切换上就会花过多时间。

  • 优先级调度

为每个进程分配一个优先级,按优先级进行调度。

为了防止低优先级的进程永远等不到调度,可以随着时间的推移增加等待进程的优先级。

  • 多级反馈队列

通常,如果一个进程需要执行 100 个时间片,如果采用时间片轮转调度算法,那么需要交换 100 次。

多级队列是为这种需要连续执行多个时间片的进程考虑,它设置了多个队列,每个队列时间片大小都不同,例如 1,2,4,8,..。进程在第一个队列没执行完,就会被移到下一个队列。这种方式下,之前的进程只需要交换 7 次。

每个队列优先权也不同,最上面的优先权最高。因此只有上一个队列没有进程在排队,才能调度当前队列上的进程。

可以将这种调度算法看成是时间片轮转调度算法和优先级调度算法的结合。

  1. 实时系统

实时系统要求一个请求在一个确定时间内得到响应。

分为硬实时和软实时,前者必须满足绝对的截止时间,后者可以容忍一定的超时。

进程同步

  • 临界区

对临界资源进行访问的那段代码称为临界区。

为了互斥访问临界资源,每个进程在进入临界区之前,需要先进行检查。

 entry section
 critical section;
 exit section
  • 同步与互斥

同步:多个进程按一定顺序执行;

互斥:多个进程在同一时刻只有一个进程能进入临界区。

  • 信号量
P 和 V 是来源于两个荷兰语词汇,P() ---prolaag (荷兰语,尝试减少的意思),V() ---verhoog(荷兰语,增加的意思)

信号量(Semaphore)是一个整型变量,可以对其执行 down 和 up 操作,也就是常见的 P 和 V 操作。

  • down : 如果信号量大于 0 ,执行 -1 操作;如果信号量等于 0,进程睡眠,等待信号量大于 0;(阻塞)
  • up :对信号量执行 +1 操作,唤醒睡眠的进程让其完成 down 操作。(唤醒)

down 和 up 操作需要被设计成原语,不可分割,通常的做法是在执行这些操作的时候屏蔽中断。

如果信号量的取值只能为 0 或者 1,那么就成为了 互斥量(Mutex) ,0 表示临界区已经加锁,1 表示临界区解锁。

typedef int semaphore;
semaphore mutex = 1;
void P1() {
    down(&mutex);
    // 临界区
    up(&mutex);
}

void P2() {
    down(&mutex);
    // 临界区
    up(&mutex);
}
  • 使用信号量实现生产者-消费者问题

通常,使用一个缓冲区来保存数据,只有缓冲区没有满,生产者才可以放入数据;只有缓冲区不为空,消费者才可以拿走数据。

因为缓冲区属于临界资源,因此需要使用一个互斥量 mutex 来控制对缓冲区的互斥访问。

为了同步生产者和消费者的行为,需要记录缓冲区中数据的数量。数量可以使用信号量来进行统计,这里需要使用两个信号量:empty 记录空缓冲区的数量,full 记录满缓冲区的数量。其中,empty 信号量是在生产者进程中使用,当 empty 不为 0 时,生产者才可以放入数据;full 信号量是在消费者进程中使用,当 full 信号量不为 0 时,消费者才可以取走数据。

这里需要注意,不能先对缓冲区进行加锁,再测试信号量。也就是说,不能先执行 down(mutex) 再执行 down(empty)。如果这么做了,那么可能会出现这种情况:生产者对缓冲区加锁后,执行 down(empty) 操作,发现 empty = 0,此时生产者睡眠。消费者不能进入临界区,因为生产者对缓冲区加锁了,也就无法执行 up(empty) 操作,empty 永远都为 0,那么生产者和消费者就会一直等待下去,造成死锁。

#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;

void producer() {
    while(TRUE){
        int item = produce_item(); // 生产一个产品
        // down(&empty) 和 down(&mutex) 不能交换位置,否则造成死锁
        down(&empty); // 记录空缓冲区的数量,这里减少一个产品空间
        down(&mutex); // 互斥锁
        insert_item(item);
        up(&mutex); // 互斥锁
        up(&full); // 记录满缓冲区的数量,这里增加一个产品
    }
}

void consumer() {
    while(TRUE){
        down(&full); // 记录满缓冲区的数量,减少一个产品
        down(&mutex); // 互斥锁
        int item = remove_item();
        up(&mutex); // 互斥锁
        up(&empty); // 记录空缓冲区的数量,这里增加一个产品空间
        consume_item(item);
    }
}
  • 管程

管程 (Monitors,也称为监视器) 是一种程序结构,结构内的多个子程序(对象或模块)形成的多个工作线程互斥访问共享资源。

使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制,而管程把控制的代码独立出来,不仅不容易出错,也使得客户端代码调用更容易。

管程是为了解决信号量在临界区的 PV 操作上的配对的麻烦,把配对的 PV 操作集中在一起,生成的一种并发编程方法。其中使用了条件变量这种同步机制。

c 语言不支持管程,下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法,客户端代码通过调用这两个方法来解决生产者-消费者问题。

monitor ProducerConsumer
    integer i;
    condition c;

    procedure insert();
    begin
        // ...
    end;

    procedure remove();
    begin
        // ...
    end;
end monitor;

管程有一个重要特性:在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程,否者其它进程永远不能使用管程。

管程引入了 条件变量 以及相关的操作:wait() 和 signal() 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞,把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。

  • 经典同步问题
  1. 读-写问题

允许多个进程同时对数据进行读操作,但是不允许读和写以及写和写操作同时发生。

Rcount:读操作的进程数量(Rcount=0)

CountMutex:对于Rcount进行加锁(CountMutex=1)

WriteMutex:互斥量对于写操作的加锁(WriteMutex=1)

Rcount = 0;
semaphore CountMutex = 1;
semaphore WriteMutex = 1;

void writer(){
    while(true){
        sem_wait(WriteMutex);
        // TO DO write();
        sem_post(WriteMutex);
    }
}

// 读者优先策略
void reader(){
    while(true){
        sem_wait(CountMutex);
        if(Rcount == 0)
            sem_wait(WriteMutex);
        Rcount++;
        sem_post(CountMutex);

        // TO DO read();

        sem_wait(CountMutex);
        Rcount--;
        if(Rcount == 0)
            sem_post(WriteMutex);
        sem_post(CountMutex);
    }
}
  1. 哲学家进餐问题

五个哲学家围着一张圆桌,每个哲学家面前放着食物。哲学家的生活有两种交替活动:吃饭以及思考。当一个哲学家吃饭时,需要先拿起自己左右两边的两根筷子,并且一次只能拿起一根筷子。

第一种方案:

下面是一种错误的解法,考虑到如果所有哲学家同时拿起左手边的筷子,那么就无法拿起右手边的筷子,造成死锁。

#define N 5           // 哲学家个数
void philosopher(int i)   {// 哲学家编号:0 - 4
    while(TRUE)
    {
        think();            // 哲学家在思考
        take_fork(i);           // 去拿左边的叉子
        take_fork((i + 1) % N); // 去拿右边的叉子
        eat();              // 吃面条中….
        put_fork(i);            // 放下左边的叉子
        put_fork((i + 1) % N);  // 放下右边的叉子
    }
}

第二种方案:

对拿叉子的过程进行了改进,但仍不正确.

#define N 5     // 哲学家个数
while(1){       
    take_fork(i);           // 去拿左边的叉子
    if(fork((i+1)%N)) {     // 右边叉子还在吗
        take_fork((i + 1) % N);// 去拿右边的叉子
        break;          // 两把叉子均到手
    }
    else {              // 右边叉子已不在
        put_fork(i);        // 放下左边的叉子
        wait_some_time();   // 等待一会儿
    }
}

第三种方案:

等待时间随机变化。可行,但非万全之策.

#define N 5     // 哲学家个数
while(1) {       
    take_fork(i);           // 去拿左边的叉子
    if(fork((i+1)%N)) {     // 右边叉子还在吗
        take_fork((i + 1) % N);// 去拿右边的叉子
        break;          // 两把叉子均到手
    }
    else {              // 右边叉子已不在
        put_fork(i);        // 放下左边的叉子
        wait_random_time( );    // 等待随机长时间
    }
}

第四种方案:

互斥访问。正确,但每次只允许一人进餐

semaphore mutex    // 互斥信号量,初值1
void philosopher(int i)  // 哲学家编号i:0-4  
{
    while(TRUE){
        think();            // 哲学家在思考
        P(mutex);           // 进入临界区
        take_fork(i);           // 去拿左边的叉子
        take_fork((i + 1) % N); // 去拿右边的叉子
        eat();              // 吃面条中….
        put_fork(i);            // 放下左边的叉子
        put_fork((i + 1) % N);  // 放下右边的叉子
        V(mutex);           // 退出临界区
    }
}

正确方案如下:

为了防止死锁的发生,可以设置两个条件(临界资源):

  • 必须同时拿起左右两根筷子;
  • 只有在两个邻居都没有进餐的情况下才允许进餐。
//1. 必须由一个数据结构,来描述每个哲学家当前的状态
#define N 5
#define LEFT i // 左邻居
#define RIGHT (i + 1) % N    // 右邻居
#define THINKING 0
#define HUNGRY   1
#define EATING   2
typedef int semaphore;
int state[N];                // 跟踪每个哲学家的状态

//2. 该状态是一个临界资源,对它的访问应该互斥地进行
semaphore mutex = 1;         // 临界区的互斥

//3. 一个哲学家吃饱后,可能要唤醒邻居,存在着同步关系
semaphore s[N];              // 每个哲学家一个信号量

void philosopher(int i) {
    while(TRUE) {
        think();
        take_two(i);
        eat();
        put_tow(i);
    }
}

void take_two(int i) {
    P(&mutex);  // 进入临界区
    state[i] = HUNGRY; // 我饿了
    test(i); // 试图拿两把叉子
    V(&mutex); // 退出临界区
    P(&s[i]); // 没有叉子便阻塞
}

void put_tow(i) {
    P(&mutex);
    state[i] = THINKING;
    test(LEFT);
    test(RIGHT);
    V(&mutex);
}

void test(i) {         // 尝试拿起两把筷子
    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
        state[i] = EATING;
        V(&s[i]); // 通知第i个人可以吃饭了
    }
}

进程通信

进程同步与进程通信很容易混淆,它们的区别在于:

  • 进程同步:控制多个进程按一定顺序执行
  • 进程通信:进程间传输信息

进程通信是一种手段,而进程同步是一种目的。也可以说,为了能够达到进程同步的目的,需要让进程进行通信,传输一些进程同步所需要的信息。

进程通信方式:

  • 直接通信
    发送进程直接把消息发送给接收进程,并将它挂在接收进程的消息缓冲队列上,接收进程从消息缓冲队列中取得消息。

Send 和 Receive 原语的使用格式如下:

Send(Receiver,message);//发送一个消息message给接收进程Receiver
Receive(Sender,message);//接收Sender进程发送的消息message
  • 间接通信

间接通信方式是指进程之间的通信需要通过作为共享数据结构的实体。该实体用来暂存发送进程发给目标进程的消息。

发送进程把消息发送到某个中间实体中,接收进程从中间实体中取得消息。这种中间实体一般称为信箱,这种通信方式又称为信箱通信方式。该通信方式广泛应用于计算机网络中,相应的通信系统称为电子邮件系统。

  • 管道

管道是通过调用 pipe 函数创建的,fd[0] 用于读,fd[1] 用于写。

#include <unistd.h>
int pipe(int fd[2]);

它具有以下限制:

  • 只支持半双工通信(单向传输)
  • 只能在父子进程中使用

  • 命名管道

命名管道的作用是,管道只能在父子进程中使用的限制。

#include <sys/stat.h>
int mkfifo(const char *path, mode_t mode);
int mkfifoat(int fd, const char *path, mode_t mode);

FIFO 常用于客户-服务器应用程序中,FIFO 用作汇聚点,在客户进程和服务器进程之间传递数据。

  • 消息队列

消息队列相比于 FIFO,消息队列具有以下优点:

消息队列可以独立于读写进程存在,从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难;

  • 避免了 FIFO 的同步阻塞问题,不需要进程自己提供同步方法;
  • 读进程可以根据消息类型有选择地接收消息,而不像 FIFO 那样只能默认地接收。

  • 信号量

它是一个计数器,用于为多个进程提供对共享数据对象的访问。

  • 共享内存

允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制,所以这是最快的一种 IPC。

需要使用信号量用来同步对共享存储的访问。

多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件,而是使用使用内存的匿名段。

  • 套接字

套接字与其它通信机制不同的是,它可用于不同机器间的进程通信。

线程间通信和进程间通信

  • 线程间通信
  1. synchronized同步

synchronized同步本质上就是 “共享内存” 式的通信。多个线程需要访问同一个共享变量,谁拿到了锁(获得了访问权限),谁就可以执行。

  1. while轮询的方式

while轮询的方式就是,ThreadA 不断地改变条件,ThreadB 不停地通过 while 语句检测这个条件 (list.size()5) 是否成立 ,从而实现了线程间的通信。但是这种方式会浪费 CPU 资源。这个有点浪费资源。

  1. wait/notify机制

当条件未满足时,ThreadA 调用 wait() 放弃 CPU,并进入阻塞状态。(不像 while 轮询那样占用 CPU)

当条件满足时,ThreadB 调用 notify() 通知线程 A,所谓通知线程 A,就是唤醒线程 A,并让它进入可运行状态。

  • 进程间通信
  1. 管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。
  2. 命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关 系 进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
  3. 信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送 信号给进程本身;Linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数)。
  4. 消息(Message)队列 :消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺
  5. 共享内存 :使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。
  6. 内存映射(mapped memory):内存映射允许任何多个进程间通信,每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。
  7. 信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。
  8. 套接口(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:linux和System V的变种都支持套接字。

进程操作

Linux进程结构可由三部分组成:

  • 代码段(程序)
  • 数据段(数据)
  • 堆栈段(控制块PCB)

进程控制块是进程存在的惟一标识,系统通过PCB的存在而感知进程的存在。系统通过 PCB 对进程进行管理和调度。PCB 包括创建进程、执行进程、退出进程以及改变进程的优先级等。

一般程序转换为进程分以下几个步骤:

  1. 内核将程序读入内存,为程序分配内存空间.
  2. 内核为该进程分配进程标识符 PID 和其他所需资源.
  3. 内核为进程保存 PID 及相应的状态信息,把进程放到运行队列中等待执行,程序转化为进程后可以被操作系统的调度程序调度执行了.

在 UNIX 里,除了进程 0(即 PID=0 的交换进程,Swapper Process)以外的所有进程都是由其他进程使用系统调用 fork 创建的,这里调用 fork 创建新进程的进程即为父进程,而相对应的为其创建出的进程则为子进程,因而除了进程 0 以外的进程都只有一个父进程,但一个进程可以有多个子进程。操作系统内核以进程标识符(Process Identifier,即 PID )来识别进程。进程 0 是系统引导时创建的一个特殊进程,在其调用 fork 创建出一个子进程(即 PID=1 的进程 1,又称 init)后,进程 0 就转为交换进程(有时也被称为空闲进程),而进程1(init进程)就是系统里其他所有进程的祖先。

进程0:Linux引导中创建的第一个进程,完成加载系统后,演变为进程调度、交换及存储管理进程。   进程1:init 进程,由0进程创建,完成系统的初始化. 是系统中所有其它用户进程的祖先进程。

Linux中 1 号进程是由 0 号进程来创建的,因此必须要知道的是如何创建 0 号进程,由于在创建进程时,程序一直运行在内核态,而进程运行在用户态,因此创建 0 号进程涉及到特权级的变化,即从特权级 0 变到特权级 3,Linux 是通过模拟中断返回来实现特权级的变化以及创建 0 号进程,通过将 0 号进程的代码段选择子以及程序计数器EIP直接压入内核态堆栈,然后利用 iret 汇编指令中断返回跳转到 0 号进程运行。

  • 创建一个进程

进程是系统中基本的执行单位。Linux 系统允许任何一个用户进程创建一个子进程,创建成功后,子进程存在于系统之中,并且独立于父进程。该子进程可以接受系统调度,可以得到分配的系统资源。系统也可以检测到子进程的存在,并且赋予它与父进程同样的权利。

Linux系统下使用 fork() 函数创建一个子进程,其函数原型如下:

#include <unistd.h>
pid_t fork(void);

在讨论 fork() 函数之前,有必要先明确父进程和子进程两个概念。除了 0 号进程(该进程是系统自举时由系统创建的)以外,Linux 系统中的任何一个进程都是由其他进程创建的。创建新进程的进程,即调用 fork() 函数的进程就是父进程,而新创建的进程就是子进程。

fork() 函数不需要参数,返回值是一个进程标识符 (PID)。对于返回值,有以下 3 种情况:

  1. 对于父进程,fork() 函数返回新创建的子进程的 ID。

  2. 对于子进程,fork() 函数返回 0。由于系统的 0 号进程是内核进程,所以子进程的进程标识符不会是0,由此可以用来区别父进程和子进程。

  3. 如果创建出错,则 fork() 函数返回 -1。

fork() 函数会创建一个新的进程,并从内核中为此进程分配一个新的可用的进程标识符 (PID),之后,为这个新进程分配进程空间,并将父进程的进程空间中的内容复制到子进程的进程空间中,包括父进程的数据段和堆栈段,并且和父进程共享代码段(写时复制)。这时候,系统中又多了一个进程,这个进程和父进程一模一样,两个进程都要接受系统的调度。

下面给出的示例程序用来创建一个子进程,该程序在父进程和子进程中分别输出不同的内容。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
    pid_t pid; // 保存进程ID
    pid = fork(); // 创建一个新进程
    if(pid < 0){ // fork出错
        printf("fail to fork\n");
        exit(1);
    }else if(pid == 0){ // 子进程
        // 打印子进程的进程ID
        printf("this is child, pid is : %u\n", getpid()); 
    }else{
        // 打印父进程和其子进程的进程ID
        printf("this is parent, pid is : %u, child-pid is : %u\n", getpid(), pid);  
    }
    return 0;
}

运行 :

> ./fork 
Parent, PID: 2598, Sub-process PID: 2599
Sub-process, PID: 2599, PPID: 2598

由于创建的新进程和父进程在系统看来是地位平等的两个进程,所以运行机会也是一样的,我们不能够对其执行先后顺序进行假设,先执行哪一个进程取决于系统的调度算法。如果想要指定运行的顺序,则需要执行额外的操作。正因为如此,程序在运行时并不能保证输出顺序和上面所描述的一致。

getpid() 是获得当前进程的pid,而 getppid() 则是获得父进程的 id。

  • 父子进程的共享资源

子进程完全复制了父进程的地址空间的内容,包括堆栈段和数据段的内容。子进程并没有复制代码段,而是和父进程共用代码段。这样做是存在其合理依据的,因为子进程可能执行不同的流程,那么就会改变数据段和堆栈段,因此需要分开存储父子进程各自的数据段和堆栈段。但是代码段是只读的,不存在被修改的问题,因此这一个段可以让父子进程共享,以节省存储空间.

该程序定义了一个全局变量 global、一个局部变量 stack 和一个指针 heap。该指针用来指向一块动态分配的内存区域。之后,该程序创建一个子进程,在子进程中修改 global、stack 和动态分配的内存中变量的值。然后在父子进程中分别打印出这些变量的值。由于父子进程的运行顺序是不确定的,因此我们先让父进程额外休眠2秒,以保证子进程先运行。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
// 全局变量,在数据段中
int global; 
int main(){
    pid_t pid;
    int stack = 1; // 局部变量,在栈中
    int * heap;
    heap = (int *)malloc(sizeof(int)); // 动态分配的内存,在堆中
    *heap = 2;
    pid = fork(); // 创建一个子进程
    if(pid < 0){ // 创建子进程失败
        printf("fail to fork\n");
        exit(1);    
    }else if(pid == 0){ // 子进程,改变各变量的值
        global++; // 修改栈、堆和数据段
        stack++;
        (*heap)++;
        printf("the child, data : %d, stack : %d, heap : %d\n", global, stack, *heap);
        exit(0); // 子进程运行结束
    }
       // 父进程休眠2秒钟,保证子进程先运行
    sleep(2); 
       // 输出结果
    printf("the parent, data : %d, stack : %d, heap : %d\n", global, stack, *heap);
    return 0;
}

程序运行效果如下:

> ./fork 
In sub-process, global: 2, stack: 2, heap: 3
In parent-process, global: 1, stack: 1, heap: 2

由于父进程休眠了2秒钟,子进程先于父进程运行,因此会先在子进程中修改数据段和堆栈段中的内容。因此不难看出,子进程对这些数据段和堆栈段中内容的修改并不会影响到父进程的进程环境。

  • fork()函数的出错情况

有两种情况可能会导致fork()函数出错:

  1. 系统中已经有太多的进程存在了.

  2. 调用fork()函数的用户进程太多了.

一般情况下,系统都会对一个用户所创建的进程数加以限制。如果操作系统不对其加限制,那么恶意用户可以利用这一缺陷攻击系统。下面是一个利用进程的特性编写的一个病毒程序,该程序是一个死循环,在循环中不断调用fork()函数来创建子进程,直到系统中不能容纳如此多的进程而崩溃为止。

#include <unistd.h>
int main(){
    while(1)
        fork(); /* 不断地创建子进程,使系统中进程溢满 */
    return 0;
}
  • 创建共享空间的子进程

进程在创建一个新的子进程之后,子进程的地址空间完全和父进程分开。父子进程是两个独立的进程,接受系统调度和分配系统资源的机会均等,因此父进程和子进程更像是一对兄弟。如果父子进程共用父进程的地址空间,则子进程就不是独立于父进程的。

Linux环境下提供了一个与 fork() 函数类似的函数,也可以用来创建一个子进程,只不过新进程与父进程共用父进程的地址空间,其函数原型如下:

#include <unistd.h>
pid_t vfork(void);

vfork() 和 fork() 函数的区别如下:

  1. vfork() 函数产生的子进程和父进程完全共享地址空间,包括代码段、数据段和堆栈段,子进程对这些共享资源所做的修改,可以影响到父进程。由此可知,vfork() 函数与其说是产生了一个进程,还不如说是产生了一个线程。

  2. vfork() 函数产生的子进程一定比父进程先运行,也就是说父进程调用了 vfork() 函数后会等待子进程运行后再运行。

在子进程中,我们先让其休眠 2 秒以释放 CPU 控制权,在前面的 fork() 示例代码中我们已经知道这样会导致其他线程先运行,也就是说如果休眠后父进程先运行的话,则第 1 点则为假;否则为真。第 2 点为真,则会先执行子进程,那么全局变量便会被修改,如果第 1 点为真,那么后执行的父进程也会输出与子进程相同的内容。

//@file vfork.c
//@brief vfork() usage
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int global = 1;

int main(void){
    pid_t pid;
    int   stack = 1;
    int  *heap;

    heap = (int *)malloc(sizeof(int));
    *heap = 1;

    pid = vfork();
    if (pid < 0){
        perror("fail to vfork");
        exit(-1);
    }else if (pid == 0) {
        //sub-process, change values
        sleep(2);//release cpu controlling
        global = 999;
        stack  = 888;
        *heap  = 777;
        //print all values
        printf("In sub-process, global: %d, stack: %d, heap: %d\n",global,stack,*heap);
        exit(0);
    }else{
        //parent-process
        printf("In parent-process, global: %d, stack: %d, heap: %d\n",global,stack,*heap);
    }

    return 0;
}

运行

> ./vfork 
In sub-process, global: 999, stack: 888, heap: 777
In parent-process, global: 999, stack: 888, heap: 777
  • 在函数内部调用vfork

在使用 vfork() 函数时应该注意不要在任何函数中调用 vfork() 函数。下面的示例是在一个非 main 函数中调用了 vfork() 函数。该程序定义了一个函数 f1(),该函数内部调用了 vfork() 函数。之后,又定义了一个函数 f2(),这个函数没有实际的意义,只是用来覆盖函数 f1() 调用时的栈帧。main 函数中先调用 f1() 函数,接着调用 f2() 函数。

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

int f1(void){
    vfork();
    return 0;
}

int f2(int a, int b){
    return a+b;
}

int main(void){
    int c;

    f1();
    c = f2(1,2);
    printf("%d\n",c);

    return 0;
}

运行:

> ./vfork 
3
Segmentation fault (core dumped)

通过运行结果可以看出,一个进程运行正常,打印出了预期结果,而另一个进程似乎出了问题,发生了段错误。出现这种情况的原因可以用下图来分析一下:

调用 vfork() 之后产生了一个子进程,并且和父进程共享堆栈段,两个进程都要从 f1() 函数返回。由于子进程先于父进程运行,所以子进程先从 f1() 函数中返回,并且调用 f2() 函数,其栈帧覆盖了原来 f1() 函数的栈帧。当子进程运行结束,父进程开始运行时,就出现了右图的情景,父进程需要从 f1() 函数返回,但是 f1() 函数的栈帧已经被 f2() 函数的所替代,因此就会出现父进程返回出错,发生段错误的情况。

由此可知,使用 vfork() 函数之后,子进程对父进程的影响是巨大的,其同步就很必要的了。

  • 退出进程

当一个进程需要退出时,需要调用退出函数。Linux 环境下使用 exit() 函数退出进程,其函数原型如下:

#include <stdlib.h>
void exit(int status);

exit() 函数的参数表示进程的退出状态,这个状态的值是一个整型,保存在全局变量 ?中,在 shell 中可以通过 echo? 来检查退出状态值。

注意:这里退出函数会深入内核注销掉进程的内核数据结构,并且释放掉进程的资源。

  • exit函数与内核函数的关系

exit 函数是一个标准的库函数,其内部封装了 Linux 系统调用 exit() 函数。两者的主要区别在于 exit() 函数会在用户空间做一些善后工作,例如清理用户的 I/O 缓冲区,将其内容写入 磁盘文件等,之后才进入内核释放用户进程的地址空间;而 exit() 函数直接进入内核释放用户进程的地址空间,所有用户空间的缓冲区内容都将丢失。

  • 设置进程所有者

每个进程都有两个用户 ID,实际用户 ID 和有效用户 ID。通常这两个 ID 的值是相等的,其取值为进程所有者的用户 ID。但是,在有些场合需要改变进程的有效用户 ID。Linux 环境下使用 setuid() 函数改变一个进程的实际用户ID和有效用户ID,其函数原型如下:

#include <unistd.h>
int setuid(uid_t uid);

setuid() 函数的参数表示改变后的新用户 ID,如果成功修改当前进程的实际用户 ID 和有效用户 ID,函数返回值为 0;如果失败,则返回 -1。只有两种用户可以修改进程的实际用户 ID 和有效用户 ID:

  1. 根用户:根用户可以将进程的实际用户 ID 和有效用户 ID 更换。

  2. 其他用户:其该用户的用户 ID 等于进程的实际用户 ID 或者保存的用户 ID。

用户可以将自己的有效用户 ID 改回去。这种情况多出现于下面的情况:一个进程需要具有某种权限,所以将其有效用户 ID 设置为具有这种权限的用户 ID,当进程不需要这种权限时,进程还原自己之前的有效用户 ID,使自己的权限复原。下面给出一个修改的示例:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void){
    FILE *fp;
    uid_t uid;
    uid_t euid;
    uid = getuid();     /* 得到进程的实际用户ID */
    euid = geteuid();   /* 得到进程的有效用户ID */
    printf("the uid is : %d\n", uid);
    printf("the euid is : %d\n", euid);
    if(setuid(8000) == -1){ /* 改变进程的实际用户ID和有效用户ID */
        perror("fail to set uid");
        exit(1);
    }
    printf("after changing\n");
    uid = getuid();     /* 再次得到进程的实际用户ID */
    euid = geteuid();   /* 再次得到进程的有效用户ID */
    printf("the uid is : %d\n", uid);
    printf("the euid is : %d\n", euid);
    return 0;
}

运行:

> ./setuid
the uid is : 0
the euid is : 0
after changing
the uid is : 8000
the euid is : 8000

孤儿进程和僵尸进程

在 Unix/Linux 中,正常情况下,子进程是通过父进程创建的,子进程在创建新的进程。子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程 到底什么时候结束。当一个进程完成它的工作终止之后,它的父进程需要调用 wait() 或者 waitpid() 系统调用取得子进程的终止状态。

孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被 init 进程(进程号为1)所收养,并由 init 进程对它们完成状态收集工作.

僵尸进程:一个进程使用 fork 创建子进程,如果子进程退出,而父进程并没有调用 wait 或 waitpid 获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程。

  • 问题和影响

Unix 提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息,就可以得到。这种机制就是:在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。但是仍然为其保留一定的信息(包括进程号 the process ID,退出状态 the termination status of the process,运行时间 the amount of CPU time taken by the process 等)。直到父进程通过 wait / waitpid 来取时才释放。但这样就导致了问题,如果进程不调用 wait / waitpid 的话, 那么保留的那段信息就不会释放,其进程号就会一直被占用,但是系统所能使用的进程号是有限的,如果大量的产生僵死进程,将因为没有可用的进程号而导致系统不能产生新的进程。此即为僵尸进程的危害,应当避免。

孤儿进程是没有父进程的进程,孤儿进程这个重任就落到了 init 进程身上,init 进程就好像是一个民政局,专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候,内核就把孤 儿进程的父进程设置为 init,而 init 进程会循环地 wait() 它的已经退出的子进程。这样,当一个孤儿进程凄凉地结束了其生命周期的时候,init 进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

任何一个子进程(init除外)在exit() 之后,并非马上就消失掉,而是留下一个称为僵尸进程 (Zombie) 的数据结构,等待父进程处理。这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后,父进程没有来得及处理,这时用 ps 命令就能看到子进程的状态是 Z。如果父进程能及时处理,可能用 ps 命令就来不及看到子进程的僵尸状态,但这并不等于子进程不经过僵尸状态。如果父进程在子进程结束之前退出,则子进程将由 init 接管。 init 将会以父进程的身份对僵尸状态的子进程进行处理。

僵尸进程影响场景:

例如有个进程,它定期的产生一个子进程,这个子进程需要做的事情很少,做完它该做的事情之后就退出了,因此这个子进程的生命周期很短,但是,父进程只管生成新的子进程,至于子进程退出之后的事情,则一概不闻不问,这样,系统运行上一段时间之后,系统中就会存在很多的僵死进程,倘若用 ps 命令查看的话,就会看到很多状态为 Z 的进程。 严格地来说,僵死进程并不是问题的根源,最有危害的是产生出大量僵死进程的那个父进程。因此,当我们寻求如何消灭系统中大量的僵死进程时,答案就是把产生大 量僵死进程的那个元凶枪毙掉(也就是通过 kill 发送 SIGTERM 或者 SIGKILL 信号啦)。kill了真正元凶进程之后,它产生的僵死进程就变成了孤儿进程,这些孤儿进程会被 init 进程接管,init 进程会 wait() 这些孤儿进程,释放它们占用的系统进程表中的资源,这样,这些已经僵死的孤儿进程就能瞑目而去了。

  • 孤儿进程应用示例
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>

int main(){
    pid_t pid;
    //创建一个进程
    pid = fork();
    //创建失败
    if (pid < 0){
        perror("fork error:");
        exit(1);
    }

    //子进程
    if (pid == 0){
        printf("I am the child process.\n");
        //输出进程ID和父进程ID
        printf("pid: %d\tppid:%d\n",getpid(),getppid());
        printf("I will sleep five seconds.\n");
        //睡眠5s,保证父进程先退出
        sleep(5);
        printf("pid: %d\tppid:%d\n",getpid(),getppid());
        printf("child process is exited.\n");
    }else{
        //父进程
        printf("I am father process.\n");
        //父进程睡眠1s,保证子进程输出进程id
        sleep(1);
        printf("father process is  exited.");
    }
    return 0;
}

运行:

> ./test
I am father process.
I am the child process.
pid:3906  ppid:3905
I will sleep five seconds.
father process is exited.
  • 僵尸进程应用示例:
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

int main(){
    pid_t pid;
    pid = fork();
    if (pid < 0){
        perror("fork error:");
        exit(1);
    }else if (pid == 0){
        printf("I am child process.I am exiting.\n");
        exit(0);
    }
    printf("I am father process.I will sleep two seconds\n");
    //等待子进程先退出

    sleep(2);
    //输出进程信息

    system("ps -o pid,ppid,state,tty,command");
    printf("father process is exiting.\n");
    return 0;
}

运行:

> ./test
I am father process.I will sleep five seconds.
I am child process.I am exiting.
PID   PPID   S   TT        COMMAND
3344  3343   S   PTS/1    -bash
4061  3344   S   PTS/1    ./test
4062  4061   Z   PTS/1    [test] <default> 
4063  4061   R   PTS/1    ps -o pid,ppid,state,tty,command
father process is exiting.

  • 僵尸进程解决办法

  • 通过信号机制

子进程退出时向父进程发送SIGCHILD信号,父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程.

  • fork两次

将子进程成为孤儿进程,从而其的父进程变为 init 进程,通过 init 进程可以处理僵尸进程.

守护进程

Linux Daemon(守护进程)是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。它不需要用户输入就能运行而且提供某种服务,不是对整个系统就是对某个用户程序提供服务。Linux系统的大多数服务器就是通过守护进程实现的。常见的守护进程包括系统日志进程syslogd、 web服务器httpd、邮件服务器sendmail和数据库服务器mysqld等。

守护进程一般在系统启动时开始运行,除非强行终止,否则直到系统关机都保持运行。守护进程经常以超级用户(root)权限运行,因为它们要使用特殊的端口(1-1024)或访问某些特殊的资源。

一个守护进程的父进程是init进程,因为它真正的父进程在fork出子进程后就先于子进程exit退出了,所以它是一个由init继承的孤儿进程。守护进程是非交互式程序,没有控制终端,所以任何输出,无论是向标准输出设备stdout还是标准出错设备stderr的输出都需要特殊处理。

守护进程的名称通常以d结尾,比如sshd、xinetd、crond等

编写守护进程的一般步骤步骤:

  • 在父进程中执行 fork 并 exit 推出;

  • 在子进程中调用 setsid 函数创建新的会话;

  • 在子进程中调用 chdir 函数,让根目录 / 成为子进程的工作目录;

  • 在子进程中调用umask函数,设置进程的umask 为 0;

  • 在子进程中关闭任何不需要的文件描述符

上下文切换

上下文切换,有时也称做进程切换或任务切换,是指CPU从一个进程或线程切换到另一个进程或线程。 在操作系统中,CPU 切换到另一个进程需要保存当前进程的状态并恢复另一个进程的状态:当前运行任务转为就绪(或者挂起、删除)状态,另一个被选定的就绪任务成为当前任务.

死锁

造成死锁的原因主要是有两种:

  1. 可重用资源引起的
  2. 消耗资源过多引起的
  • 什么是死锁
  1. 什么是死锁
    造成死锁的原因就是多个线程或进程对同一个资源的争抢或相互依赖。一个最简单的解释就是你去面试,面试官问你告诉我什么是死锁,我就录用你,你回答面试官你录用我,我告诉你。

如果一个进程集合里面的每个进程都在等待只能由这个集合中的其他一个进程(包括他自身)才能引发的事件,这种情况就是死锁。

我们可以看一个例子,有资源 A、B,进程 C、D 描述如下:

资源 A 和资源 B,都是不可剥夺资源,现在进程 C 已经申请了资源 A,进程 D 也申请了资源 B,进程 C 接下来的操作需要用到资源 B,而进程 D 恰好也在申请资源A,进程 C、D 都得不到接下来的资源,那么就引发了死锁。

然后套用回去定义:如果一个进程集合里面(进程 C 和进程 D)的每个进程(进程 C 和进程 D)都在等待只能由这个集合中的其他一个进程(对于进程 C,他在等进程 D;对于进程 D,他在等进程 C)才能引发的事件(释放相应资源)。

这里的资源包括,软件(程序)和硬件(扫描仪)。 资源一般可以分两种:可剥夺资源(Preemptable)和不可剥夺资源 (Nonpreemptable)。一般来说对于由可剥夺资源引起的死锁可以由系统的重新分配资源来解决,所以一般来说大家说的死锁都是由于不可剥夺资源所引起的。

  1. 死锁的必要条件

  • 互斥:每个资源要么已经分配给了一个进程,要么就是可用的。
  • 占有和等待:已经得到了某个资源的进程可以再请求新的资源。
  • 不可抢占:已经分配给一个进程的资源不能强制性地被抢占,它只能被占有它的进程显式地释放。
  • 循环等待:有两个或者两个以上的进程组成一条环路,该环路中的每个进程都在等待下一个进程所占有的资源。
  1. 死锁的处理方法

处理死锁的策略:

  • 鸵鸟策略

把头埋在沙子里,假装根本没发生问题。
因为解决死锁问题的代价很高,因此鸵鸟策略这种不采取任务措施的方案会获得更高的性能。当发生死锁时不会对用户造成多大影响,或发生死锁的概率很低,可以采用鸵鸟策略。
大多数操作系统,包括 Unix,Linux 和 Windows,处理死锁问题的办法仅仅是忽略它。
检测死锁并且恢复。

仔细地对资源进行动态分配,以避免死锁。

通过破除死锁四个必要条件之一,来防止死锁产生。

死锁检测与死锁恢复:

不试图阻止死锁,而是当检测到死锁发生时,采取措施进行恢复。

(一) 每种类型一个资源的死锁检测

图中是资源分配图,其中方框表示资源,圆圈表示进程。资源指向进程表示该资源已经分配给该进程,进程指向资源表示进程请求获取该资源。

图 a 可以抽取出环,如图 b,它满足了环路等待条件,因此会发生死锁。

每种类型一个资源的死锁检测算法是通过检测有向图是否存在环来实现,从一个节点出发进行深度优先搜索,对访问过的节点进行标记,如果访问了已经标记的节点,就表示有向图存在环,也就是检测到死锁的发生。

(二) 每种类型多个资源的死锁检测

图中有三个进程四个资源,每个数据代表的含义如下:

  • E 向量:资源总量.
  • A 向量:资源剩余量.
  • C 矩阵:每个进程所拥有的资源数量,每一行都代表一个进程拥有资源的数量.
  • R 矩阵:每个进程请求的资源数量.

因此就会有:

每个进程最开始时都不被标记,执行过程有可能被标记。当算法结束时,任何没有被标记的进程都是死锁进程。

  1. 寻找一个没有标记的进程 Pi,它所请求的资源小于等于 A。
  2. 如果找到了这样一个进程,那么将 C 矩阵的第 i 行向量加到 A 中,标记该进程,并转回 1。
  3. 如果没有这样一个进程,算法终止。

(三)死锁恢复

  • 利用抢占恢复
  • 利用回滚恢复
  • 通过杀死进程恢复

  • 死锁预防

在程序运行之前预防发生死锁,确保系统永远不会进入死锁状态。

(一) 破坏互斥条件

破坏互斥条件最明显的例子就是,脱机打印机技术允许若干个进程同时输出,唯一真正请求物理打印机的进程是打印机守护进程。(把互斥地封装成可以同时访问的,例如:打印机的缓存).

(二) 破坏占有和等待条件

一种实现方式是规定所有进程在开始执行前请求所需要的全部资源。

但是,这种策略也有如下缺点:

  • 在许多情况下,一个进程在执行之前不可能知道它所需要的全部资源。这是由于进程在执行时是动态的,不可预测的;
  • 资源利用率低。无论所分资源何时用到,一个进程只有在占有所需的全部资源后才能执行。即使有些资源最后才被该进程用到一次,但该进程在生存期间却一直占有它们,造成长期占着不用的状况。这显然是一种极大的资源浪费;
  • 降低了进程的并发性。因为资源有限,又加上存在浪费,能分配到所需全部资源的进程个数就因此少了。

(三) 破坏不可抢占条件

允许进程强行从占有者那里夺取某些资源。就是说,当一个进程已占有了某些资源,它又申请新的资源,但不能立即被满足时,它必须释放所占有的全部资源,以后再重新申请。它所释放的资源可以分配给其它进程。这就相当于该进程占有的资源被隐蔽地强占了。这种预防死锁的方法实现起来困难,会降低系统性能。

(四) 破坏循环等待

实行资源有序分配策略。采用这种策略,即把资源事先分类编号,按号分配,使进程在申请,占用资源时不会形成环路。所有进程对资源的请求必须严格按资源序号递增的顺序提出。进程占用了小号资源,才能申请大号资源,就不会产生环路,从而预防了死锁。这种策略与前面的策略相比,资源的利用率和系统吞吐量都有很大提高,但是也存在以下缺点:

  • 限制了进程对资源的请求,同时给系统中所有资源合理编号也是件困难事,并增加了系统开销;
  • 为了遵循按编号申请的次序,暂不使用的资源也需要提前申请,从而增加了进程对资源的占用时间。

  • 死锁避免

在程序运行时避免发生死锁,在使用前进行判断,只允许不会出现死锁的进程请求资源。

(一)安全状态

图中 a 的第二列 Has 表示已拥有的资源数,第三列 Max 表示总共需要的资源数,Free 表示还有可以使用的资源数。从图 a 开始出发,先让 B 拥有所需的所有资源(图 b),运行结束后释放 B,此时 Free 变为 5(图 c);接着以同样的方式运行 C 和 A,使得所有进程都能成功运行,因此可以称图 a 所示的状态时安全的。

定义:如果没有死锁发生,并且即使所有进程突然请求对资源的最大需求,也仍然存在某种调度次序能够使得每一个进程运行完毕,则称该状态是安全的。

安全状态的检测与死锁的检测类似,因为安全状态必须要求不能发生死锁。下面的银行家算法与死锁检测算法非常类似,可以结合着做参考对比。

(二)单个资源的银行家算法

一个小镇的银行家,银行家向一群客户分别承诺了一定的贷款额度,算法要做的是判断对请求的满足是否会进入不安全状态,如果是,就拒绝请求;否则予以分配。

图中c 为不安全状态,因此算法会拒绝之前的请求,从而避免进入图 c 中的状态。

(三) 多个资源的银行家算法

图中有五个进程,四个资源。左边的图表示已经分配的资源,右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示:总资源、已分配资源以及可用资源,注意这三个为向量,而不是具体数值,例如 A=(1020),表示 4 个资源分别还剩下 1/0/2/0。

检查一个状态是否安全的算法如下:

  • 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行,那么系统将会发生死锁,状态是不安全的。
  • 假若找到这样一行,将该进程标记为终止,并将其已分配资源加到 A 中。
  • 重复以上两步,直到所有进程都标记为终止,则状态时安全的。

但是,如果一个状态不是安全的,那么就拒绝进入这个状态。

  • 如何在程序开发中避免死锁

死锁,发生的主要原因在于了有多个进程去竞争资源,也就是同时去抢占。

可以自己写一个支持多线程的消息管理类,单开一个线程访问独占资源,其它线程用消息交互实现间接访问。 这种机制适应性强、效率高,更适合多核环境。

内存管理

  1. 虚拟内存

虚拟内存是当代操作系统必备的一项重要功能了,它向进程屏蔽了底层了RAM和磁盘,并向进程提供了远超物理内存大小的内存空间。

虚拟内存的目的是为了让物理内存扩充成更大的逻辑内存,从而让程序获得更多的可用内存。引入虚拟内存后,每个进程都要各自的虚拟内存,内存的并发访问问题的粒度从多进程级别,可以降低到多线程级别。

为了更好的管理内存,操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间,这个地址空间被分割成多个块,每一块称为一页。这些页被映射到物理内存,但不需要映射到连续的物理内存,也不需要所有页都必须在物理内存中。当程序引用到一部分不在物理内存中的地址空间时,由硬件执行必要的映射,将缺失的部分装入物理内存并重新执行失败的指令

由此可以看出,虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存,也就是说一个程序不需要全部调入内存就可以运行,这使得有限的内存运行大程序称为可能。例如有一台计算机可以产生 16 位地址,那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存,虚拟内存技术允许该计算机运行一个 64K 大小的程序。

  1. 分页系统地址映射
  • 内存管理单元(MMU):管理着地址空间和物理内存的转换。
  • 页表(Page table):页(地址空间)和页框(物理内存空间)的映射表。例如下图中,页表的第 0 个表项为 010,表示第 0 个页映射到第 2 个页框。页表项的最后一位用来标记页是否在内存中。

页表存放着 16 个页,这 16 个页需要用 4 个比特位来进行索引定位。因此对于虚拟地址(0010 000000000100),前 4 位是用来存储页面号,而后 12 位存储在页中的偏移量。

(0010 000000000100)根据前 4 位得到页号为 2,读取表项内容为(110 1),它的前 3 为为页框号,最后 1 位表示该页在内存中。最后映射得到物理内存地址为(110 000000000100)。

  1. 页面置换算法

在程序运行过程中,如果要访问的页面不在内存中,就发生缺页中断从而将该页调入内存中。此时如果内存已无空闲空间,系统必须从内存中调出一个页面到磁盘对换区中来腾出空间。

页面置换算法和缓存淘汰策略类似,可以将内存看成磁盘的缓存。在缓存系统中,缓存的大小有限,当有新的缓存到达时,需要淘汰一部分已经存在的缓存,这样才有空间存放新的缓存数据。

页面置换算法的主要目标是使页面置换频率最低(也可以说缺页率最低)。

  • Optimal

所选择的被换出的页面将是最长时间内不再被访问,通常可以保证获得最低的缺页率。

是一种理论上的算法,因为无法知道一个页面多长时间不再被访问。

例如:一个系统为某进程分配了三个物理块,并有如下页面引用序列:70120304230321201701

开始运行时,先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时,产生缺页中断,会将页面 7 换出,因为页面 7 再次被访问的时间最长。

  • Least Recently Used(LRU)

虽然无法知道将来要使用的页面情况,但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。

为了实现 LRU,需要在内存中维护一个所有页面的链表。当一个页面被访问时,将这个页面移到链表表头。这样就能保证链表表尾的页面时最近最久未访问的。

因为每次访问都需要更新链表,因此这种方式实现的 LRU 代价很高。

  • Not Recently Used(NRU)

每个页面都有两个状态位:R 与 M,当页面被访问时设置页面的 R=1,当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类:

R=0,M=0
R=0,M=1
R=1,M=0
R=1,M=1

当发生缺页中断时,NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。

NRU 优先换出已经被修改的脏页面(R=0,M=1),而不是被频繁使用的干净页面(R=1,M=0)。

  1. First In First Out(FIFO)

选择换出的页面是最先进入的页面。

该算法会将那些经常被访问的页面也被换出,从而使缺页率升高。

  1. 第二次机会算法

FIFO 算法可能会把经常使用的页面置换出去,为了避免这一问题,对该算法做一个简单的修改:

当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候,检查最老页面的 R 位。如果 R 位是 0,那么这个页面既老又没有被使用,可以立刻置换掉;如果是 1,就将 R 位清 0,并把该页面放到链表的尾端,修改它的装入时间使它就像刚装入的一样,然后继续从链表的头部开始搜索。

  1. Clock

第二次机会算法需要在链表中移动页面,降低了效率。时钟算法使用环形链表将页面链接起来,再使用一个指针指向最老的页面。

  • 分段

虚拟内存采用的是分页技术,也就是将地址空间划分成固定大小的页,每一页再与内存进行映射。

下图为一个编译器在编译过程中建立的多个表,有 4 个表是动态增长的,如果使用分页系统的一维地址空间,动态增长的特点会导致覆盖问题的出现。

分段的做法是把每个表分成段,一个段构成一个独立的地址空间。每个段的长度可以不同,并且可以动态增长。

  • 段页式

程序的地址空间划分成多个拥有独立地址空间的段,每个段上的地址空间划分成大小相同的页。这样既拥有分段系统的共享和保护,又拥有分页系统的虚拟内存功能。

  • 分页与分段的比较
  1. 对程序员的透明性:分页透明,但是分段需要程序员显示划分每个段。
  2. 地址空间的维度:分页是一维地址空间,分段是二维的。
  3. 大小是否可以改变:页的大小不可变,段的大小可以动态改变。
  4. 出现的原因:分页主要用于实现虚拟内存,从而获得更大的地址空间;分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。

这里在补充一下对比内存,寄存器、cache、内存、磁盘的各自特点.

这个图表达了计算机的存储体系,从上至下依次是:

  • CPU寄存器

  • Cache

  • 内存

  • 硬盘等辅助存储设备

  • 鼠标等外接设备

从上至下,访问速度越来越慢,访问时间越来越长。

CPU速度很快,但硬盘等持久存储很慢,如果CPU直接访问磁盘,磁盘可以拉低CPU的速度,机器整体性能就会低下,为了弥补这2个硬件之间的速率差异,所以在CPU和磁盘之间增加了比磁盘快很多的内存。

然而,CPU跟内存的速率也不是相同的,从上图可以看到,CPU的速率提高的很快(摩尔定律),然而内存速率增长的很慢,虽然CPU的速率现在增加的很慢了,但是内存的速率也没增加多少,速率差距很大,从1980年开始CPU和内存速率差距在不断拉大,为了弥补这2个硬件之间的速率差异,所以在CPU跟内存之间增加了比内存更快的Cache,Cache是内存数据的缓存,可以降低CPU访问内存的时间。

计算机的存储体系介绍:

  1. 寄存器: 寄存器是中央处理器的组成部份,可用来暂存指令、数据和位址。通常有通用寄存器,如指令寄存器IR、程序计数器(PC)、累加器(ACC)、堆栈指针寄存器(SP)等,另外还有状态寄存器(标记状态Z、N、V、C)。寄存器最靠近CPU,随取随用,速度最快。

  2. Cache:

即高速缓冲存储器,位于CPU与内存之间,容量小但速度快。由于CPU快而内存慢,CPU不存在直接读或者写内存的情况,每次读或者写内存都要访问Cache。

Cache Line是cache与内存同步的最小单位,典型的虚拟内存页面大小为4K,Cache line为32或64字节。Cache中一般保存着CPU刚用过或循环使用的部分数据,当CPU再次使用该部分数据时可从Cache中直接调用,这样就抹平了CPU与内存的速度差。Cache又分为L1、L2、L3(L1、L2一般集成在CPU上)。

理论上L1有着跟寄存器相同的速度,但L1工作在写通过(write-through)模式下时,需要加锁用来同步cache和内存的内容,这段期间L1不能被访问,所以L1就没寄存器快。L2、L3同样需要加锁,并且L2比L1慢,L3比L2慢。因此呢,L1速率最快,与CPU速率最接近,是RAM速率的100倍,L2速率就降到了RAM的25倍,L3的速率更靠近RAM的速率。

Cache下还有一个TLB,TLB是一个内存管理单元用于改进虚拟地址到物理地址转换速度的缓存。

  1. RAM(主要针对DRAM):

即内存,其作用是用于暂存CPU的运算数据,以及与硬盘等外部存储器交换的数据。内存的一个存储周期是从存储器收到有效地址(EA)开始,经过地址译码、驱动,直到被访问的存储单元被读出/写入为止。

简单介绍下CPU访问内存的流程:

  • 找到数据(一般为操作数)地址(或地址的地址)。(地址一般放在通用寄存器内)
  • 将地址送往内存管理单元(MMU),由MMU将虚拟的内存地址翻译成实际的物理地址。
  • 将物理地址送往内存控制器,由控制器进行译码找到对应的存储体。
  • 从对应的存储体读取数据送回给控制器,最后再送回CPU。

可以看出内存的工作流程比cache多出许多,每一步都会产生延迟。并且当外围设备(比如磁盘)通过DMA控制器与内存进行数据传输时(走数据总线),会与上面的CPU访问内存发生冲突,此时CPU和DMA就会轮流挪用内存周期,这样CPU访问内存的速度就更慢了。

  1. HardDisk

HardDisk又称硬盘驱动器,常见的有磁性旋转机械盘和基于闪存的固态硬盘SSD,这里主要讲机械盘,当进行数据存取时,主要的速度影响来自于磁头的寻道时间和盘片的旋转时间,通常需要花费数毫秒的时间。如果是顺序I/O还好,如果是随机I/O,速度将很慢。虽然磁盘内部、操作系统及应用程序都对磁盘进行了缓存优化,但速度还是远远不及内存。

由此可以看到存储体系的分层设计,自顶向下,速率越来越低,访问时间越来越长,从磁盘到CPU寄存器,上一层都可以看做是下一层的缓存。

设备管理

磁盘结构主要包括:

  • 盘面(Platter):一个磁盘有多个盘面;
  • 磁道(Track):盘面上的圆形带状区域,一个盘面可以有多个磁道;
  • 扇区(Track Sector):磁道上的一个弧段,一个磁道可以有多个扇区,它是最小的物理储存单位,目前主要有 512 bytes 与 4 K 两种大小;
  • 磁头(Head):与盘面非常接近,能够将盘面上的磁场转换为电信号(读),或者将电信号转换为盘面的磁场(写);
  • 制动手臂(Actuator arm):用于在磁道之间移动磁头;
  • 主轴(Spindle):使整个盘面转动。


磁盘调度算法:

读写一个磁盘块的时间的影响因素有:

  • 旋转时间(主轴旋转磁盘,使得磁头移动到适当的扇区上)
  • 寻道时间(制动手臂移动,使得磁头移动到适当的磁道上)
  • 实际的数据传输时间
    其中,寻道时间最长,因此磁盘调度的主要目标是使磁盘的平均寻道时间最短。
  1. 先来先服务(First Come First Served,简称FCFS)
  • 按照磁盘请求的顺序进行调度
  • 公平对待所有进程
  • 在有很多进程的情况下,接近随机调度的性能
  • 优点是公平和简单。缺点也很明显,因为未对寻道做任何优化,使平均寻道时间可能较长。

  1. 最短寻道时间优先(Shortest Seek Time First,简称SSTF)

优先调度与当前磁头所在磁道距离最近的磁道。

虽然平均寻道时间比较低,但是不够公平。如果新到达的磁道请求总是比一个在等待的磁道请求近,那么在等待的磁道请求会一直等待下去,也就是出现饥饿现象。具体来说,两边的磁道请求更容易出现饥饿现象。

  1. 电梯算法(SCAN)

电梯总是保持一个方向运行,直到该方向没有请求为止,然后改变运行方向。

电梯算法(扫描算法)和电梯的运行过程类似,总是按一个方向来进行磁盘调度,直到该方向上没有未完成的磁盘请求,然后改变方向。

因为考虑了移动方向,因此所有的磁盘请求都会被满足,解决了 SSTF 的饥饿问题。

系统处理过程

  1. 编译系统

以下是一个 main.c 程序:

#include <stdio.h>
int main(){
    printf("Golang is Best Language\n");
    return 0;
}

在 Unix 系统上,由编译器把源文件转换为目标文件。

gcc -o main main.c

整个运行过程:

  • 预处理阶段 (Preprocessing phase)

预处理(cpp)根据以字符 # 开头的命令,修改原始的 C 程序,生成扩展名为 .i 的文件。

> gcc -E main.c -o main.i
  • 编译阶段 (Compilation phase)

编译器(cc1)将文本文件 main.i 翻译成文本文件 main.s,它包含一个汇编语言程序。

> gcc -S main.i -o main.s
  • 汇编阶段 (Assembly phase)

编译器(as)将 main.s 翻译成机器语言指令,把这些指令打包成一种叫做可重定位目标程序(relocatable object program)的格式,并将结果保存在目标文件 main.o 中。

>  as main.s -o main.o
  • 链接阶段 (Linking phase)
    printf 函数是标准 C 库中的一个函数,在 printf.o 这个单独预编译好的目标文件中。连接器(ld)将 printf.o 和 main.o 合并,结果得到 main 可执行目标文件。
> gcc main.o -o main
  1. 静态链接

静态连接器以一组可重定向目标文件为输入,生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务:

  • 符号解析:每个符号对应于一个函数、一个全局变量或一个静态变量,符号解析的目的是将每个符号引用与一个符号定义关联起来。
  • 重定位:链接器通过把每个符号定义与一个内存位置关联起来,然后修改所有对这些符号的引用,使得它们指向这个内存位置。

  1. 目标文件
  • 可执行目标文件:可以直接在内存中执行;
  • 可重定向目标文件:可与其它可重定向目标文件在链接阶段合并,创建一个可执行目标文件;
  • 共享目标文件:这是一种特殊的可重定向目标文件,可以在运行时被动态加载进内存并链接;
  1. 动态链接

静态库有以下两个问题:

  • 当静态库更新时那么整个程序都要重新进行链接;
  • 对于 printf 这种标准函数库,如果每个程序都要有代码,这会极大浪费资源。

共享库是为了解决静态库的这两个问题而设计的,在 Linux 系统中通常用 .so 后缀来表示,Windows 系统上它们被称为 DLL。它具有以下特点:

  • 在给定的文件系统中一个库只有一个文件,所有引用该库的可执行目标文件都共享这个文件,它不会被复制到引用它的可执行文件中;
  • 在内存中,一个共享库的 .text 节(已编译程序的机器代码)的一个副本可以被不同的正在运行的进程共享。

Linux基础

Linux基础

1. 异步和非阻塞的区别

异步和非阻塞的区别:

  • 异步:调用在发出之后,这个调用就直接返回,不管有无结果;异步是过程。
  • 非阻塞:关注的是程序在等待调用结果(消息,返回值)时的状态,指在不能立刻得到结果之前,该调用不会阻塞当前线程。

同步和异步的区别:

  • 同步:一个服务的完成需要依赖其他服务时,只有等待被依赖的服务完成后,才算完成,这是一种可靠的服务序列。要么成功都成功,失败都失败,服务的状态可以保持一致。
  • 异步:一个服务的完成需要依赖其他服务时,只通知其他依赖服务开始执行,而不需要等待被依赖的服务完成,此时该服务就算完成了。被依赖的服务是否最终完成无法确定,一次它是一个不可靠的服务序列。

消息通知中的同步和异步:

  • 同步:当一个同步调用发出后,调用者要一直等待返回消息(或者调用结果)通知后,才能进行后续的执行。
  • 异步:当一个异步过程调用发出后,调用者不能立刻得到返回消息(结果)。在调用结束之后,通过消息回调来通知调用者是否调用成功。

阻塞与非阻塞的区别:

  • 阻塞:阻塞调用是指调用结果返回之前,当前线程会被挂起,一直处于等待消息通知,不能够执行其他业务,函数只有在得到结果之后才会返回。
  • 非阻塞:非阻塞和阻塞的概念相对应,指在不能立刻得到结果之前,该函数不会阻塞当前线程,而会立刻返回。

同步与异步是对应的,它们是线程之间的关系,两个线程之间要么是同步的,要么是异步的。

阻塞与非阻塞是对同一个线程来说的,在某个时刻,线程要么处于阻塞,要么处于非阻塞。

阻塞是使用同步机制的结果,非阻塞则是使用异步机制的结果。

2. 虚拟内存作用是什么

我们都知道一个进程是与其他进程共享CPU和内存资源的。正因如此,操作系统需要有一套完善的内存管理机制才能防止进程之间内存泄漏的问题.

为了更加有效地管理内存并减少出错,现代操作系统提供了一种对主存的抽象概念,即是虚拟内存(Virtual Memory)。虚拟内存为每个进程提供了一个一致的、私有的地址空间,它让每个进程产生了一种自己在独享主存的错觉(每个进程拥有一片连续完整的内存空间)。

虚拟内存的重要意义是它定义了一个连续的虚拟地址空间,使得程序的编写难度降低。并且,把内存扩展到硬盘空间只是使用虚拟内存的必然结果,虚拟内存空间会存在硬盘中,并且会被内存缓存(按需),有的操作系统还会在内存不够的情况下,将某一进程的内存全部放入硬盘空间中,并在切换到该进程时再从硬盘读取.

虚拟内存主要提供了如下三个重要的能力:

  • 它把主存看作为一个存储在硬盘上的虚拟地址空间的高速缓存,并且只在主存中缓存活动区域(按需缓存)。

  • 它为每个进程提供了一个一致的地址空间,从而降低了程序员对内存管理的复杂性。

  • 它还保护了每个进程的地址空间不会被其他进程破坏。

3. Linux查看端口占用和cpu负载

linux ps命令,查看某进程cpu和内存占用率情况:

> ps aux
USER               PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
admin            72824  17.3  1.4  5518204 118212   ??  R    27 519   54:49.93 /Applications/iTerm.app/Contents/MacOS/iTerm2
_windowserver      179  16.1  0.6  7525352  46552   ??  Rs   21 519  457:09.25 /System/Library/PrivateFrameworks/SkyLight.fra
admin              734  12.2  3.3  6095348 273108   ??  R    21 519  635:17.25 /Users/admin/Desktop/Google Chrome.app/Content
admin            10718   9.0  2.7  5604388 223604   ??  S    22 519  557:56.89 /Users/admin/Desktop/Google Chrome.app/Content
admin              750   6.4  0.6  4633300  52372   ??  S    21 519  147:59.59 /Users/admin/Desktop/Google Chrome.app/Content
admin              749   5.6  1.2  5570904  96832   ??  S    21 519  359:56.37 /Users/admin/Desktop/Google Chrome.app/Content
admin              818   4.5  0.1  6557980   5508   ??  S    21 519  557:27.52 com.docker.hyperkit -A -u -F vms/0/hyperkit.pi
admin            32898   3.5  1.4  4977204 117684   ??  S    10:54上午   0:02.27 /Users/admin/Desktop/Google Chrome.app/Content
admin            30591   2.2  3.7  9505844 310584   ??  S     9:47上午  10:49.28 /Applications/GoLand.app/Contents/MacOS/goland
root              1300   1.9  0.1  4334916   6212   ??  Ss   21 519  123:53.86 /usr/libexec/taskgated
admin            31232   1.2  1.1 10553808  88860   ??  S    10:24上午   3:28.67 /Applications/WebStorm.app/Contents/MacOS/webs
admin            18704   0.7  0.2 19282032  12948   ??  S     3:56下午   4:18.12 /private/var/folders/kp/3yqnp9cj4f3_9539b06q4
  • linux 下的ps命令
  • USER 进程运行用户
  • PID 进程编号
  • %CPU 进程的cpu占用率
  • %MEM 进程的内存占用率
  • VSZ 进程所使用的虚存的大小
  • RSS 进程

4. Linux如何发送信号给一个进程

通常在linux中可以通过pkill 命令、kill 命令和 killall 命令,或者组合键向进程发送各种信号.

  • Ctrl + C: 中断信号,发送 SIGINT 信号到运行在前台的进程.
  • Ctrl + Y: 延时挂起信号,使运行的进程在尝试从终端读取输入时停止。控制权返回给 Shell,使用户可以将进程放在前台或后台,或杀掉该进程.
  • Ctrl + Z: 挂起信号,发送 SIGTSTP 信号到运行的进程,由此将其停止,并将控制权返回给 Shell.
    也可以使用 kill命令结束进程:

发送SIGKILL信号到PID是 123 的进程:

> kill -9 123

killall 命令会发送信号到运行任何指定命令的所有进程。所以,当一个进程启动了多个实例时,使用killall命令来杀掉这些进程会更方便一些。

  • 使用 killall 命令杀掉所有 firefox 进程:
> killall firefox

使用 pkill 命令,可以通过指定进程名、用户名、组名、终端、UID、EUID和GID等属性来杀掉相应的进程。pkill 命令默认也是发送 SIGTERM 信号到进程。

  • 使用 pkill 命令杀掉所有用户的 firefox 进程.
> pkill firefox

5. 如何避免死锁

死锁是指多个进程因竞争资源而造成的一种僵局(互相等待),若无外力作用,这些进程都将无法向前推进。
例如,在某一个计算机系统中只有一台打印机和一台输入 设备,进程P1正占用输入设备,同时又提出使用打印机的请求,但此时打印机正被进程P2 所占用,而P2在未释放打印机之前,又提出请求使用正被P1占用着的输入设备。
这样两个进程相互无休止地等待下去,均无法继续执行,此时两个进程陷入死锁状态。

死锁产生的原因:

  1. 系统资源的竞争

系统资源的竞争导致系统资源不足,以及资源分配不当,导致死锁。

  1. 进程运行推进顺序不合适

进程在运行过程中,请求和释放资源的顺序不当,会导致死锁。

死锁的四个必要条件:

  • 互斥条件:一个资源每次只能被一个进程使用,即在一段时间内某 资源仅为一个进程所占有。此时若有其他进程请求该资源,则请求进程只能等待。

  • 请求与保持条件:进程已经保持了至少一个资源,但又提出了新的资源请求,而该资源 已被其他进程占有,此时请求进程被阻塞,但对自己已获得的资源保持不放。

  • 不可剥夺条件:进程所获得的资源在未使用完毕之前,不能被其他进程强行夺走,即只能 由获得该资源的进程自己来释放(只能是主动释放)。

  • 循环等待条件: 若干进程间形成首尾相接循环等待资源的关系

这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁。

死锁的避免与预防:

  • 死锁避免的基本思想

系统对进程发出的每一个系统能够满足的资源申请进行动态检查,并根据检查结果决定是否分配资源,如果分配后系统可能发生死锁,则不予分配,否则予以分配,这是一种保证系统不进入死锁状态的动态策略。
如果操作系统能保证所有进程在有限时间内得到需要的全部资源,则系统处于安全状态否则系统是不安全的。

  • 安全状态

如果系统存在 由所有的安全序列{P1,P2,…Pn},则系统处于安全状态。一个进程序列是安全的,如果对其中每一个进程Pi(i >=1 && i <= n)他以后尚需要的资源不超过系统当前剩余资源量与所有进程Pj(j < i)当前占有资源量之和,系统处于安全状态则不会发生死锁。
不安全状态:如果不存在任何一个安全序列,则系统处于不安全状态。

我们可以通过破坏死锁产生的4个必要条件来预防死锁,由于资源互斥是资源使用的固有特性是无法改变的。

  • 破坏“不可剥夺”条件:一个进程不能获得所需要的全部资源时便处于等待状态,等待期间他占有的资源将被隐式的释放重新加入到系统的资源列表中,可以被其他的进程使用,而等待的进程只有重新获得自己原有的资源以及新申请的资源才可以重新启动,执行。

  • 破坏”请求与保持条件“:第一种方法静态分配即每个进程在开始执行时就申请他所需要的全部资源。第二种是动态分配即每个进程在申请所需要的资源时他本身不占用系统资源。

  • 破坏“循环等待”条件:采用资源有序分配其基本思想是将系统中的所有资源顺序编号,将紧缺的,稀少的采用较大的编号,在申请资源时必须按照编号的顺序进行,一个进程只有获得较小编号的进程才能申请较大编号的进程。

6. 孤儿进程和僵尸进程区别

  • 孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。
    孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作。

  • 僵尸进程:一个进程使用fork创建子进程,如果子进程退出,而父进程并没有调用wait或waitpid获取子进程的状态信息,那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

7. 滑动窗口的概念以及应用

滑窗(sliding window)被同时应用于接收方和发送方。发送方和接收方各有一个滑窗。当片段位于滑窗中时,表示TCP正在处理该片段。滑窗中可以有多个片段,也就是可以同时处理多个片段。

滑窗越大,越大的滑窗同时处理的片段数目越多(当然,计算机也必须分配出更多的缓存供滑窗使用)。

滑动窗口概念不仅存在于数据链路层,也存在于传输层,两者有不同的协议,但基本原理是相近的。其中一个重要区别是,一个是针对于帧的传送,另一个是字节数据的传送。

滑动窗口(Sliding window)是一种流量控制技术。早期的网络通信中,通信双方不会考虑网络的拥挤情况直接发送数据。

由于大家不知道网络拥塞状况,同时发送数据,导致中间节点阻塞掉包,谁也发不了数据,所以就有了滑动窗口机制来解决此问题。参见滑动窗口如何根据网络拥塞发送数据仿真视频。

滑动窗口协议是用来改善吞吐量的一种技术,即容许发送方在接收任何应答之前传送附加的包。接收方告诉发送方在某一时刻能送多少包(称窗口尺寸)。

CP中采用滑动窗口来进行传输控制,滑动窗口的大小意味着接收方还有多大的缓冲区可以用于接收数据。

发送方可以通过滑动窗口的大小来确定应该发送多少字节的数据。当滑动窗口为0时,发送方一般不能再发送数据报,但有两种情况除外,一种情况是可以发送紧急数据,例如,允许用户终止在远端机上的运行进程。

另一种情况是发送方可以发送一个1字节的数据报来通知接收方重新声明它希望接收的下一字节及发送方的滑动窗口大小。

8. Epoll和Select的区别

  • epoll 和 select 都是 I/O 多路复用的技术,都可以实现同时监听多个 I/O 事件的状态。
  • epoll 相比 select 效率更高,主要是基于其操作系统支持的I/O事件通知机制,而 select 是基于轮询机制。
  • epoll 支持水平触发和边沿触发两种模式。

9. 进程之间为什么要进行通信呢

  • 数据传输:一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几兆字节之间。
  • 共享数据:多个进程想要操作共享数据,一个进程对共享数据的修改,别的进程应该立刻看到。
  • 通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)。
  • 资源共享:多个进程之间共享同样的资源。为了作到这一点,需要内核提供锁和同步机制。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。

10. 输入PingIP后敲回车,发包前会发生什么

首先根据目的IP和路由表决定走哪个网卡,再根据网卡的子网掩码地址判断目的IP是否在子网内。
如果不在则会通过arp缓存查询IP的网卡地址,不存在的话会通过广播询问目的IP的mac地址,得到后就开始发包了,同时mac地址也会被arp缓存起来。

11. 进程和进程间的通信方式区别和不同

进程: 计算机中是资源分配的基本单位。

进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态,所谓的创建进程和撤销进程,都是指对 PCB 的操作。

线程: 是独立调度的基本单位。

一个进程中可以有多个线程,它们共享进程资源。

例如QQ 和浏览器是两个进程,浏览器进程里面有很多线程,例如 HTTP 请求线程、事件响应线程、渲染线程等等,线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时,浏览器还可以响应用户的其它事件。

在 linux 下进程间通信主要是:

  • 管道(Pipe)及有名管道(named pipe):管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信;

  • 信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送信号给进程本身;linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数);

  • 消息队列(Message):消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺点。

  • 共享内存:使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。

  • 信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。

  • 套接口(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:Linux和System V的变种都支持套接字。

12. 如何查看二进制可执行文件引用的动态链接库

linux中可以用ldd查看,macOs中可以用otool可以查看.