系统

培训

一. 名词解释

• PID：进程ID
• PPID：父进程ID

二. 进程

2.1 进程状态

主要状态：

• 运行态：进程占用CPU，并在CPU上运行
• 就绪态：进程已经具备运行条件，但是CPU还没有分配过来（时间片）
• 阻塞态：进程因等待某件事发生而暂时不能运行
• 挂起态：不占用系统资源，当满足条件后，重新分配资源

其他状态：

• 可运行态：他是运行态和就绪态的合并，表示进程正在运行或准备运行，Linux 中使用TASK_RUNNING 宏表示此状态。
• 浅度睡眠态：进程正在睡眠（被阻塞），等待资源到来是唤醒，也可以通过其他进程信号或时钟中断唤醒，进入运行队列。Linux 使用TASK_INTERRUPTIBLE 宏表示此状态。
• 深度睡眠态：其和浅度睡眠基本类似，但有一点就是不可其他进程信号或时钟中断唤醒。Linux 使用TASK_UNINTERRUPTIBLE 宏表示此状态。
• 暂停状态：进程暂停执行接受某种处理。如正在接受调试的进程处于这种状态，Linux 使用TASK_STOPPED 宏表示此状态。
• 僵死状态：进程已经结束但未释放PCB，Linux 使用TASK_ZOMBIE 宏表示此状态。

关于sleep( )：

• 头文件#include <unistd.h>
• sleep()单位为秒（如果需要更精确可以用usleep单位为微秒）
• VC中Sleep()单位为毫秒（Linux中没有）
• sleep的实现是由pause函数和alarm函数两个实现的。
• 返回值
  若进程/线程挂起到参数所指定的时间则返回0，若有信号中断则返回剩余秒数。

2.2 进程的调用

• 进程需要的资源：
  栈、堆、数据、代码

+---------+            +---------+                          
| Stack栈 |            | Stack栈 |                          
+---------+            +---------+                          
|  Heep   |   fork()   |  Heep   |                          
+---------+ +--------> +---------+                          
|  DATA   |            |  DATA   |                          
+---------+            +---------+                          
|  Code   |            |  Code   |                          
+---------+            +---------+                          

• fork( )：
  将父进程资源复制一份（形成子进程），加入调度。（包括程序运行的状态，程序已经执行的位置。）
  也就是说：fork出来的子进程只会从fork处往下执行。
• 关于指针：
  指针地址是虚拟空间地址，不是实际物理地址，原来父进程有0xffff，在复制后的子进程也会有一个0xffff。但不是同一个实际物理地址。
• 堆和栈的区别:
  堆的空间是自己分配，自己释放，栈的空间是系统分配，系统释放。

pid_t fork();
//返回生成的子进程的pid（数据类型为pid_t，也是int）

说明：
在父进程中fork()返回的是子进程ID号，在fork出来的子进程中返回的是0。

返回值：
- <0：创建失败
- >0：当前运行在父进程
- =0：当前运行在子进程

• 其他创建进程的函数：

  • exec函数族
  • vfork

• exec 函数族

  • execl：
  • execlp：
  • execle：

+---------+             
| Stack栈 |             
+---------+             
|  deep   |             
+---------+             
|  DATA   |             
+---------+   exec函数族   
|         | -----------+
|         |            |
|  Code   |            |根据exec函数族的程序路径参数，将代码覆盖掉。
|         |            |
|         | <----------+
+---------+             
会将原先进程的代码全部覆盖

2.3 进程的退出

• exit( )
  库函数，在退出时会做，资源处理（缓存处理，文件处理...）最后调用_exit( )退出。

• _exit( )
  系统调用函数，直接退出，不做任何其他处理。

• 关于缓冲：

  • 全缓冲：标准IO，缓冲到4字节才会提交缓冲（例如：输入缓冲）
    printf("qwerqreqwerqre");
  • 行缓冲：遇到换行符，回车则清空(提交)缓冲
    printf("qwerqreqwerqre\n");
  • 不缓冲：输入立马输出（提交）
• 孤儿进程：
  父进程退出，子进程还在运行(子进程就成了孤儿进程，这时孤儿进程的父进程ppid，将使用1号进程的id)

• 僵尸进程：
  子进程退出，父进程还在运行且没有回收子进程的资源（子进程复制的资源还在保留）

• 避免进程僵尸：

#include<sys/types.h>
#include<sys/wait.h>
int status;//用以保存子进程的状态
pid_t pid=wait(&status);
//wait可以接收子进程的exit的状态，也可以回收子进程的资源
WEXITSTATUS(stata);
//解析子进程退出返回的状态。

2.4 进程间通信

2.4.1 方式

当子进程退出的时候会发送SIGCHLD信号给父进程，父进程可接收该信号，调用wait回收子进程

• 用kill发送信号
• 用signal拦截信号

发送信号函数特性:

• kill
  
  • 可以发给任何进程
• alarm
  
  • 只能发给自己只能是SIGALRM信号
  • 可以设置发送定时
  • 一次调用只能发送一次
• raise
  
  • 只能发给本进程
  • 可以定制发送的信号
  • 立即发送

pause();函数会暂停程序，当接收到SIGCONT信号才会继续运行。

2.4.2 有名管道

适用：同一系统的任意进程

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
//pathname:要创建的管道文件路径
//mode：文件权限

mode specifies the FIFO's permissions. It is modified by the process's umask in the usual way:the permissions of the created file are (mode & ~umask).

2.4.3 消息队列

• 获取IPC键值key----ftok()

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);//proj_id只有低八位有效0-255

• 通过键值来获取消息队列(身份唯一,队列描述符)

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);//返回队列描述符

• 往队列中发送数据

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msgbuf {
       long mtype;       /* message type, must be > 0 */
       char mtext[1];    /* message data */
       char m[1000];
};
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

• 从队列中读取数据

 ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
                      int msgflg);

• 释放队列资源

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

2.4.4 共享内存

• 获取IPC键值key----ftok()

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);//proj_id只有低八位有效0-255 

• 创建共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
返回值：int ---获取到的共享内存id（描述符）
参数： 
key_t key -- ipc键值
size_t size---共享内存空间大小（一般一页整数倍）getpagesize
int shmflg----IPC_CREAT创建---权限

• 把共享空间映射到用户空间

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
返回值：成功（映射到用户空间的首地址) 失败（(void*)-1）
参数:
int shmid----共享内存id
const void *shmaddr---用户空间地址与内存空间映射用（一般NULL系统自动分配）
int shmflg ---映射空间权限---0（可读可写）SHM_RDONLY(只读)

• 释放映射

int shmdt(const void *shmaddr); 

• 释放内空间（删除共享内存）

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

2.4.5 信号量

• 获取key

key_t key=ftok("/",123);

• 获取semid

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

IPC_EXCL 当和 IPC_CREAT 一同使用时，如果信号量集已经存在，则调用失败。
如果单独使用IPC_CREAT，则semget()要么返回新创建的信号量集的标识符，要么返回系统中已经存在的同样的关键字值的信号量的标识符。
如果 IPC_EXCL和IPC_CREAT一同使用，则要么返回新创建的信号量集的标识符，要么返回-1。
IPC_EXCL单独使用没有意

• 初始化

union semun {
   int              val;    /* Value for SETVAL */
   struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
   unsigned short  *array;  /* Array for GETALL, SETALL */
   struct seminfo  *__buf;  /* Buffer for IPC_INFO
                               (Linux-specific) */
}num;
num.val=1;
int ret=semctl(semid,0,SETVAL,num);//初始化第0个信号量

• 信号量操作（semop）

//原型
int semop(int semid, struct sembuf *sops, unsigned nsops);
//下面是sembuf的成员
unsigned short sem_num;  /* semaphore number 操作信号量的下标*/
short          sem_op;   /* semaphore operation -1获取资源，1释放资源*/
short          sem_flg;  /* operation flags 0或者IPC_NOWAIT（不阻塞）*/

三.线程

3.1 pthread_create

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                  void *(*start_routine) (void *), void *arg);

注意:
1. 子线程可以创建子线程
2. 线程内可以将线程事务函数，直接调用.(子线程可以直接调用父线程事务函数，父线程也可以直接调用子线程事务函数)
3. 线程事物函数的void类型参数记得写形参

3.2 线程退出

3.3 线程分离

分离线程不能调用pthread_join回收线程

#include <pthread.h>
int pthread_detach(pthread_t thread);

分离线程后由系统负责回收，而不需要主线程去回收。解决了pthread_join阻塞的问题。

注意：分离的线程只是将子线程的资源回收交给了系统，子线程没有脱离主线程，当主线程杀掉后，子线程也被杀掉了。(原因可能是，主线程杀掉，该进程也就杀掉了，于是进程下的所有线程也就杀掉了)

3.4 线程资源

线程共享的是进程的堆和数据段，而栈是每个线程都有自己的私有栈。

堆：保存程序代码分配的空间（malloc一类的函数分配出来的空间）
数据段：保存的是静态变量和全局变量
栈：保存的是动态变量，局部变量等数据

3.5 线程同步与互斥

3.5.1 工具

• 互斥锁
• 信号量
• 条件变量

3.5.2 互斥锁

• 初始化互斥锁

#include <pthread.h>
pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;//快速互斥锁
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;//递归互斥锁
pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;//检错互斥锁
int pthread_mutex_init(pthread_mutex_t *mutex,const thread_mutexattr_t
*mutexattr);

• 上锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);

• 解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);

• 销毁锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

3.5.3 信号量

• 信号量初始化

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);

• 获取信号量资源

int sem_wait(sem_t *sem);//

• 释放信号量资源

int sem_post(sem_t *sem);

• 销毁信号量

int sem_destory(sem_t *sem);

3.5.4 条件变量

• 初始化条件变量

#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
int pthread_cond_broadcast(pthread_cond_t *cond);

• 阻塞线程

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int  pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const
struct timespec *abstime);

• 唤醒线程

int pthread_cond_signal(pthread_cond_t *cond);

• 销毁线程

int pthread_cond_destroy(pthread_cond_t *cond);

3.5.5 线程池

• 任务表

struct rackNode{
    void *(*tack_func)(void *);
    struct tackNode *next;
}

• 线程池模型思路

1. 创建多个线程，用条件变量阻塞。
2. 将线程需要执行的函数，以指针的形式保存在任务链表中
3. 每次激活线程的时候，线程去任务表中取一个任务（取一个链表中的函数）同时，从链表中移除该节点，然后执行该节点的函数，然后free该节点。

注意：不能在线程中使用同一把互斥锁。

示例模型代码：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#include<fcntl.h>
#include<unistd.h>
#include<pthread.h>
typedef struct tackNode
{
    void (*tack_fun)(void);
    int num;
    struct tackNode *next;
}tackNode;
tackNode *create_tack(void (*tack_fun)(void))
{
    tackNode *tack = (tackNode*)malloc(sizeof(tackNode));
    if(tack == NULL)return NULL;
    tack->tack_fun = tack_fun;
    tack->next = NULL;
    return tack;
}
pthread_cond_t cont;
void *run(void *arg)
{
    tackNode *tackpool = (tackNode*)arg;
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);
    while(1)
    {
        //挂起
        pthread_cond_wait(&cont, &mutex);
        printf("-------\n");
        tackNode *ptack = tackpool->next;
        if(ptack == NULL)continue;
        tackpool->next = ptack->next;
        printf("这是第%d个任务\n", ptack->num);
        ptack->tack_fun();
    }
}
void tack(void)
{
    printf("tack--%d-start\n", pthread_self());
    sleep(10);printf("=====================\n");
    printf("tack--%d--end\n", pthread_self());
}
void add_tack(tackNode *tackpool, void (*tack)(void), int num)
{
    tackNode *new = create_tack(tack);
    new->num = num;
    new->next = tackpool->next;
    tackpool->next = new;
}
int main(void)
{
    pthread_cond_init(&cont, NULL);
    tackNode *tackpool = create_tack(NULL);
    if(tackpool == NULL) perror("create fail"),exit(-1);
    int i=0, ret =0; 
    pthread_t id = 0;
    for(i=0; i<10 ; i++)
    {
        ret = pthread_create(&id , NULL, run,(void *)tackpool);
    }
    int num =0;
    while(1)
    {
        sleep(1);
        add_tack(tackpool, tack, num++);
        pthread_cond_signal(&cont);
        if(num % 20 == 0)
        {
            sleep(30);
        }
    }
    while(1);
    return 0;
}

四.进程与线程的关系

• 一个进程中可以包含若干个线程，
• 线程可以利用进程所拥有的资源
• 进程作为分配资源的基本单位（引入线程的操作系统中）
• 线程作为独立运行和独立调度的基本单位。

区别：

• 地址空间和其它资源：
  
  • 进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
• 通信：
  
  • 进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
• 调度和切换：
  
  • 线程上下文切换比进程上下文切换要快得多。
• 在多线程OS中，进程不是一个可执行的实体。

五.文件锁

fcntl上锁:

#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, /*上锁的文件*/
        int cmd,/*命令*/
        ... /* arg flock结构体*/ 
        );
//结构体
struct flock {
   ...
   short l_type;    /* Type of lock: F_RDLCK,
                       F_WRLCK, F_UNLCK */
   short l_whence;  /* How to interpret l_start:
                       SEEK_SET, SEEK_CUR, SEEK_END */
   off_t l_start;   /* Starting offset for lock */
   off_t l_len;     /* Number of bytes to lock */
   pid_t l_pid;     /* PID of process blocking our lock
                       (F_GETLK only) */
   ...
};

flock上锁：

#include <sys/file.h>
int flock(int fd, int operation);

参数：

• int fd：文件描述符
• int operation：上锁操作
  
  • LOCK_SH 获取共享锁
  • LOCK_EX 获取互斥锁（无法获取时会阻塞）
  • LOCK_NU 解锁
  • LOCK_NB

优缺点：
简单，但是只能锁整个文件，不能锁一段文本

六.系统日志

#include <syslog.h>
void openlog(const char *ident, int option, int facility);
void syslog(int priority, const char *format, ...);
//例如：syslog(LOG_INFO, "%s", "fopen fail");
void closelog(void);