【嵌入式AI】嵌入式知识总结----操作系统

进程与线程

1、进程是资源分配的基本单位，它是程序执行时的一个实例，在程序运行时创建。
线程是程序执行的最小单位，是进程的一个执行流，一个线程由多个线程组成的。
2、进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。
线程是共享进程中的数据，使用相同的地址空间，因此，CPU切换一个线程的花费远比进程小很多，同时创建一个线程的开销也比进程小很多。
3、线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。
4、多线程程序只要有一个线程死掉，整个进程也跟着死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。
5、总结：线程执行开销小，但是不利于资源的管理和保护。线程适合在SMP机器（双CPU系统）上运行。进程执行开销大，但是能够很好的进行资源管理和保护，可以跨机器迁移。

进程状态

创建状态、就绪状态、运行状态、阻塞状态、终止状态

创建进程方式

进程之间通信

管道、消息队列、共享内存、信号量、信号、socket

管道

ps auxf | grep myspl

其中|就是管道（匿名管道），它的功能是将前一个命令（ps auxf）的输出，作为后一个命令（grep mysql）的输入。其是单向的。还有一种叫命名管道，也叫FIFO，其本质是个文件（缓存），在一个线程里往管道写，另一个线程读，必须要管道的数据被读完了才能继续执行。管道这种通信方式效率低，不适合进程间频繁地交换数据。

管道的原理

子进程产生时会复制父进程的文件描述符，即管道的输入输出，因此两个进程就可以利用这个管道通信了。

c++管道接口

FILE* popen (const char *command, const char *open_mode);  
int pclose(FILE *stream_to_close);  
fwrite(buffer, sizeof(char), chars_read, write_fp);  
fread(buffer, sizeof(char), BUFSIZ, read_fp);  

消息队列

比管道的优势为：把数据放在对应的消息队列后就可以正常返回；消息队列生命周期随内核，如果没有释放消息队列或者没有关闭操作系统，消息队列会一直存在。
消息队列不适合比较大数据的传输，因为在内核中每个消息体都有一个最大长度的限制，同时所有队列所包含的全部消息体的总长度也是有上限。
消息队列通信过程中，存在用户态与内核态之间的数据拷贝开销。因为消息队列属于内核。
c++消息队列接口

（1）int msgget(key_t key,int msgflg);
函数描述：建立消息队列
（2）int msgsnd(int msgid,struct msgbuf* msgb,int msgb_sz,int msgflg);
函数描述：将消息送入消息队列
（3）int mgsrcv(int msgid,void *ptr,size_t ptr_sz,long type,int mgsflg);
函数描述：从消息队列中读出一条新消息
(4) int msgctl(int msgid,int cmd,struct msqid_ds * buf);
函数描述：控制对消息队列的操作

共享内存

**共享内存的机制，就是拿出一块虚拟地址空间来，映射到相同的物理内存中。**这样这个进程写入的东西，另外一个进程马上就能看到了，都不需要拷贝来拷贝去，传来传去，大大提高了进程间通信的速度。
c++接口

int shmget(key_t key, size_t size, int shmflg);//创建共享内存
void *shmat(int shmid, const void *shmaddr, int shmflg);//将共享内存链接到进程地址空间
int shmctl(int shmid, int cmd, struct shmid_ds *buf);//控制共享内存

信号量

共享内存会存在冲突，信号量用于实现保护机制
信号量其实是一个整型的计数器，主要用于实现进程间的互斥与同步，而不是用于缓存进程间通信的数据。
P操作：信号量-1，如果<0，表明资源被占用，进程阻塞等待
V操作：信号量+1，相加后如果信号量 <= 0，则表明当前有阻塞中的进程，于是会将该进程唤醒运行
c++接口

int sem_init(sem_t *sem, int pshared, unsigned int value);  // 创建信号量
int sem_post(sem_t *sem);  // 信号量的值加 1
int sem_wait(sem_t *sem);  // 信号量的值减 1
int sem_destroy(sem_t *sem);  // 信号量销毁

信号

信号是进程间通信机制中唯一的异步通信机制
一旦有信号产生，就会执行以下操作：
1、执行默认操作，例如终止进程，ctrl+c等
2、捕捉信号
3、忽略信号
c++接口：

void (*signal (int sig, void (*func)(int)))(int);//捕捉信号
int raise (signal sig);//生成信号

socket

跨网络与不同主机上的进程之间通信，就需要 Socket 通信

线程同步方法

临界区、互斥量、信号量和事件

1. 临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2. 互斥量:为协调共同对一个共享资源的单独访问而设计的。
3. 信号量:为控制一个具有有限数量用户资源而设计。
4. 事件: 用来通知线程有一些事件已发生，从而启动后继任务的开始。

什么是僵尸进程，孤儿进程，守护进程

僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。僵尸进程无法用kill清除，但可以杀死他的父进程，然后用孤儿进程管理对其清理
孤儿进程：父进程异常结束了，然后被1号进程init收养。
守护进程：有意把父进程结束，然后被1号进程init收养。

并发与互斥

自旋锁和信号量

自旋锁：忙等待
信号量：忙阻塞

读写锁

可以被同时读，但不能同时读和写

示例

忘记释放锁

mutex _mutex;
void func()
{
	_mutex.lock();
	if (xxx)
	  return;
	_mutex.unlock();
}

单线程重复申请锁

mutex _mutex;
void func()
{
	_mutex.lock();
	 //do somrthing....
	_mutex.unlock();
}
 
void data_process() {
	_mutex.lock();
	func();
	_mutex.unlock();
}

双线程多锁申请

mutex _mutex1;
mutex _mutex2;
 
void process1() {
	_mutex1.lock();
	_mutex2.lock();
	//do something1...
	_mutex2.unlock();
	_mutex1.unlock();
}
 
void process2() {
	_mutex2.lock();
	_mutex1.lock();
	//do something2...
	_mutex1.unlock();
	_mutex2.unlock();
}

环形锁

避免死锁

1、线程按照一定的顺序加锁
2、线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁
3、死锁检测，当检测出死锁时，让一些线程回退，释放锁。