level6 并发程序设计

BSS段：存放程序中未初始化的全局变量
数据段：存放程序中已初始化的全局变量
代码段：存放程序执行代码
堆：存放进程运行中被动态分配的内存段（调用malloc等函数分配）
栈（又叫堆栈）：存放程序临时创建的局部变量，（但不包括static声明的变量，static意味着在数据段中存放变量）
进程类型：交互进程（在shell下启动。在前台运行，也可以在后台运行）、批处理进程（和在终端无关，被提交到一个作业队列中以便顺序执行）、守护进程（和终端无关，一直在后台运行）
进程状态：运行态、等待态、停止态、死亡态

查看进程信息

ps 查看系统进程快照

-e：显示所有进程
-l：长格式显示更加详细的信息

-f 全部列出，通常和其他选项联用

表头	含义
F	进程标志，说明进程的权限，常见的标志有两个: · 1：进程可以被复制，但是不能被执行； · 4：进程使用超级用户权限；
S	进程状态。进程状态。常见的状态有以下几种： 1. -D：不可被唤醒的睡眠状态，通常用于 I/O 情况。 2. -R：该进程正在运行。 3. -S：该进程处于睡眠状态，可被唤醒。 4. -T：停止状态，可能是在后台暂停或进程处于除错状态。 5. -W：内存交互状态（从 2.6 内核开始无效）。 6. -X：死掉的进程（应该不会出现）。 7. -Z：僵尸进程。进程已经中止，但是部分程序还在内存当中。 8. -<：高优先级（以下状态在 BSD 格式中出现）。 9. -N：低优先级。 10. -L：被锁入内存。 11. -s：包含子进程。 12. -l：多线程（小写 L）。 13. -+：位于后台。
UID	运行此进程的用户的 ID；
PID	进程的 ID；
PPID	父进程的 ID；
C	该进程的 CPU 使用率，单位是百分比；
PRI	进程的优先级，数值越小，该进程的优先级越高，越早被 CPU 执行；
NI	进程的优先级，数值越小，该进程越早被执行；
ADDR	该进程在内存的哪个位置；
SZ	该进程占用多大内存；
WCHAN	该进程是否运行。"-"代表正在运行；
TTY	该进程由哪个终端产生；
TIME	该进程占用 CPU 的运算时间，注意不是系统时间；
CMD	产生此进程的命令名；

top 查看进程动态信息
- shift +> 后翻页
- shift +< 前翻页
- top -p PID 查看某个进程
/proc 查看进程详细信息

改变进程优先级

nice 按用户指定的优先级运行进程
- nice [-n NI值] 命令
- NI 范围是 -20~19。数值越大优先级越低
- 普通用户调整 NI 值的范围是 0~19，而且只能调整自己的进程。
- 普通用户只能调高 NI 值，而不能降低。如原本 NI 值为 0，则只能调整为大于 0。
- 只有 root 用户才能设定进程 NI 值为负值，而且可以调整任何用户的进程。
renice 改变正在运行进程的优先级
- renice [优先级] PID
jobs 查看后台进程
bg 将挂起的进程在后台运行
fg 把后台运行的进程放到前台运行
ctrl+z 把运行的前台进程转为后台并停止。
./test & 把test程序后台运行

子进程创建 – fork

#include <unistd.h>

pid_t fork(void);

创建新的进程，失败时返回-1

成功时父进程返回子进程的进程号，子进程返回0

pid_t  pid;  
if ((pid = fork()) < 0)
{
  perror(“fork”);
  return -1;
}
else if(pid == 0)
{
  printf(“child  process :  my pid  is %d\n”, getpid());
}
else
{
  printf(“parent  process :  my pid  is  %d\n”, getpid());
}

通过fork的返回值区分父进程和子进程
子进程只执行fork之后的代码
父子进程执行顺序是操作系统决定的。
父子进程有独立的地址空间，互不影响
若父进程先结束，子进程成为孤儿进程，被init进程收养子进程变成后台进程
若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程

进程的退出

#include<stdlib.h>

#include<unistd.h>

void exit(int status);

void _exit(int status);

结束当前的进程并将status返回
exit结束进程时会刷新(流)缓冲区
return 和exit的区别:main函数结束时会隐式地调用exit函数，普通函数return是返回上一级。

#include <stdio.h>  
#include <stdlib.h>
int main(void)
{
     printf(“this process will exit”);
     exit(0);
     printf(“never  be  displayed”);
}
 ./a.out
 this process will be exit

进程的回收

子进程结束时由父进程回收;孤儿进程由init进程回收;若没有及时回收会出现僵尸进程

#include <unistd.h>

pid_t wait(int *status);

成功时返回回收的子进程的进程号；失败时返回EOF
若子进程没有结束，父进程一直阻塞
若有多个子进程，哪个先结束就先回收
status 指定保存子进程返回值和结束方式的地址
status为NULL表示直接释放子进程PCB,不接收返回值

int status;
pid_t pid;
if ((pid = fork()) < 0)
{
  perror(“fork”);  exit(-1);
}
else if (pid == 0)
{
  sleep(1);
  exit(2);
}
else
{
  wait(&status);
  printf(“%x\n”, status);
}

#include <unistd.h>

pid_t waitpid(pid_t pid,int *status,int option);

参数pid

pid>0	只等待进程ID等于pid的子进程
pid=0	等待同一个进程组中的任何一个子进程退出
pid=-1	等待任何一个子进程退出
pid<-1	等待一个为pid绝对值进程组中的任何子进程

参数options
提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用
WNOHANG ：若由pid指定的子进程未发生状态改变(没有结束)，则waitpid()不阻塞，立即返回0
WUNTRACED：返回终止子进程信息和因信号停止的子进程信息
wait(wait_stat) 等价于waitpid(-1,wait_stat,0)
成功时返回回收的子进程的pid或0；失败时返回EOF
pid可用于指定回收哪个子进程或任意子进程
status指定用于保存子进程返回值和结束方式的地址
option指定回收方式，0 或 WNOHANG
可以使用wait函数传出参数status来保存进程的退出状态

waitpid(pid, &status, 0);waitpid(pid, &status, WNOHANG);waitpid(-1, &status, 0);waitpid(-1, &status, WNOHANG);

2. exec函数族

fork创建进程之后，子进程和父进程执行相同的代码，但是在实际开发当中，我们希望父子进程执行不同的代码。

进程 – execl / execlp

#include<unistd.h>

int execl(const char *path, const char *arg, …);

int execlp(const char *file, const char *arg, …);

成功时执行指定的程序；失败时返回EOF
path 执行的程序名称，包含路径
arg… 传递给执行的程序的参数列表
file 执行的程序的名称，在PATH中查找

  if  (execl(“/bin/ls”, “ls”, “-a”, “-l”, “/etc”, NULL) < 0)
  {
    perror(“execl”);
  } 
  if(execlp(“ls”, “ls”, “-a”, “-l”, “/etc”, NULL) < 0)
  {
    perror(“execlp”);
  }

两个函数区别execlp不需要写文件名全路径，在PATH查找
最后一个参数必须用空指针(NULL)作结束
进程当前内容被指定的程序替换，但进程号不变
第0个参数必须要写，虽然它没有使用

进程 – execv / execvp

#include <unistd.h>

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

成功时执行指定的程序；失败时返回EOF
arg… 封装成指针数组的形式

char  *arg[] = {“ls”, “-a”, “-l”, “/etc”, NULL};
if(execv(“/bin/ls”, arg) < 0) 
{
  perror(“execv”);
}
if(execvp(“ls”, arg) < 0)
{
  perror(“execvp”);
}

进程 – system

#include <stdlib.h>

int system(const char *command);

成功时返回命令command的返回值；失败时返回EOF
当前进程等待command执行结束后才继续执行

3. 守护进程

概念：守护进程又叫精灵进程（Daemon Process），它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。
进程组（Process Group）：进程集合，每个进程组有一个组长（Leader），其进程 ID就是该进程组ID。
会话（Session）：进程组集合，每个会话有一个组长，其进程 ID 就是该会话组ID。
控制终端（Controlling Terminal）：每个会话可以有一个单独的控制终端，与控制终端连接的Leader就是控制进程（Controlling Process）。
特点：1. 始终在后台运行；2. 独立于任何终端；3. 周期性的执行某种任务或等待处理特定事件
更简便地创建守护进程：nohup 命令 nohup xxxx &
setsid函数：
- pid_t setsid(void);
- 成功：返回调用进程的会话ID；失败：-1，设置errno。调用了setsid函数的进程，既是新的会长，也是新的组长
getsid函数
- pid_t getsid(pid_t pid)
- 成功：返回调用进程的会话ID；失败：-1，设置errno
- 1.pid为0表示察看当前进程session ID
- 2.ps ajx命令查看系统中的进程。参数a表示不仅列当前用户的进程,也列出所有其他用户的进程,参数x表示不仅列有控制终端的进程,也列出所有无控制终端的进程,参数j表示列出与作业控制相关的信息。
3.组长进程不能成为新会话首进程,新会话首进程必定会成为组长进程。
getpid：pid_t getpid(void); 获取进程id
getpgid：pid_t getpgid(pid_t pid); 获取进程组id

守护进程创建

1. 创建子进程，父进程退出

if (fork() > 0)
{
  exit(0);
}

2. 子进程创建新会话

if (setsid() < 0)
{
  exit(-1);
}

3. 更改当前工作目录

chdir(“/”);
chdir(“/tmp”);

4. 重设文件权限掩码

if (umask(0) < 0)
{
  exit(-1);
}

5. 关闭打开的文件描述符

int  i;
for(i=0; i<3; i++)
{
  close(i);
}

4. GDB 调试多进程程序

set follow-fork-mode child 设置GDB调试子进程
set follow-fork-mode parent 设置GDB调试父进程
set detach-on-fork on/off 设置GDB跟踪调试单个进程或多个
- on: 只调试父进程或子进程的其中一个，(根据follow-fork-mode来决定)，这是默认的模式
- off：父子进程都在gdb的控制之下，其中一个进程正常调试(根据follow-fork-mode来决定),另一个进程会被设置为暂停状态。
info inferiors 显示GDB调试的进程
inferiors 进程序号（1,2,3....）切换GDB调试的进程

5. 线程的创建和参数传递

进程与线程的区别：进程有独立的地址空间，每个进程都参与内核调度，互不影响；线程指的是共享相同地址空间的多个任务
线程特点：1. 大大提高了任务切换的效率；2. 避免了额外的TLB & cache的刷新
一个进程中的多个线程共享以下资源：可执行的指令，静态数据，进程中打开的文件描述符，当前工作目录，用户ID，用户组ID
每个线程私有的资源包括：线程ID (TID) ，PC(程序计数器)和相关寄存器，堆栈，错误号 (errno)，优先级，执行状态和属性

线程创建

#include <pthread.h>

int pthread_create(pthread_t *thread, const

pthread_attr_t *attr, void *(*routine)(void *), void *arg);

成功返回0，失败时返回错误码
thread 线程对象
attr 线程属性，NULL代表默认属性
routine 线程执行的函数
arg 传递给routine的参数，参数是void * ，注意传递参数格式

线程结束

#include <pthread.h>

void pthread_exit(void *retval);

结束当前线程
retval可被其他线程通过pthread_join获取
线程私有资源被释放

线程查看tid函数

#include <pthread.h>

pthread_t pthread_self(void);

返回自己的TID

6. 线程的回收及内存演示

线程的回收可以像进程一样通过主进程回收线程（pthread_join函数）；也可以分离线程（pthead_detach函数或者pthread_attr_setdetachstate设置分离属性），分离的线程在结束后会自动回收

pthread_join 函数：

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

成功返回0，失败时返回错误码
thread 要回收的线程对象
调用线程阻塞直到thread结束
*retval 接收线程thread的返回值
注意：pthread_join 是阻塞函数，如果回收的线程没有结束，则一直等待

使用线程的分离

int pthread_detach(pthread_t thread);
创建线程时候设置为分离属性

pthread_attr_t attr; /*通过线程属性来设置游离态（分离态）*/

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

7. 线程的取消和清理

取消一个线程

意义：随时杀掉一个线程
线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用

int pthread_cancel(pthread_t thread); //杀死一个线程

void pthread_testcancel(void); //手动设置一个取消点

int pthread_setcancelstate(int state, int *oldstate); //设置取消使能或禁止

PTHREAD_CANCEL_ENABLE //使能

PTHREAD_CANCEL_DISABLE //禁止

int pthread_setcanceltype(int type, int *oldtype);//设置取消类型

PTHREAD_CANCEL_DEFERRED //等到取消点才取消

PTHREAD_CANCEL_ASYNCHRONOUS //目标线程会立即取消

线程的清理

必要性：当线程非正常终止，需要清理一些资源。

void pthread_cleanup_push(void (*routine) (void *), void *arg)

void pthread_cleanup_pop(int execute)

routine 函数被执行的条件：

被pthread_cancel取消掉。
执行pthread_exit
非0参数执行pthread_cleanup_pop()

必须成对使用，即使pthread_cleanup_pop不会被执行到也必须写上，否则编译错误。
pthread_cleanup_pop()被执行且参数为0，pthread_cleanup_push回调函数routine不会被执行.
pthread_cleanup_push 和pthread_cleanup_pop可以写多对，routine执行顺序正好相反
线程内的return 可以结束线程，也可以给pthread_join返回值，但不能触发pthread_cleanup_push里面的回调函数，所以我们结束线程尽量使用pthread_exit退出线程。

查看是否成功回收

先通过 ps -ef|grep a.out【程序名】找到线程号，然后通过top -p【进程号】查看 VIRT 的变化

8. 互斥锁/读写锁的概念及使用、死锁的使用

线程的互斥和同步

临界资源概念：不能同时访问的资源，比如写文件，只能由一个线程写，同时写会写乱。

比如外设打印机，打印的时候只能由一个程序使用。
外设基本上都是不能共享的资源。
必要性：临界资源不可以共享
man手册找不到 pthread_mutex_xxxxxxx （提示No manual entry for pthread_mutex_xxx）的解决方法：apt-get install manpages-posix-dev

互斥锁的创建

两种方法创建互斥锁，静态方式和动态方式
静态方式：
POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER
动态方式：
#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t * attr);

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象

attr 互斥锁属性，NULL表示缺省属性

互斥锁的销毁

int pthread_mutex_destroy(pthread_mutex_t *mutex)

在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

申请上锁

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象
区别：pthread_mutex_lock 如果无法获得锁，任务阻塞 pthread_mutex_trylock 如果无法获得锁，返回EBUSY而不是挂起等待

释放锁

#include <pthread.h>

int pthread_mutex_unlock(pthread_mutex_t *mutex);

成功时返回0，失败时返回错误码

mutex 指向要初始化的互斥锁对象执行完临界区要及时释放锁

读写锁

读写锁和互斥锁的区别：在进行写操作的时候才会互斥，而在进行读的时候是可以共享的进行访问临界区的
读写锁的必要性：提高线程执行效率
同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。
读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。
读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

读写锁相关函数

初始化一个读写锁   pthread_rwlock_init

读锁定读写锁       pthread_rwlock_rdlock

非阻塞读锁定　　   pthread_rwlock_tryrdlock

写锁定读写锁      pthread_rwlock_wrlock

非阻塞写锁定      pthread_rwlock_trywrlock

解锁读写锁         pthread_rwlock_unlock

释放读写锁         pthread_rwlock_destroy

死锁

概念：当线程1拥有资源1的权限想要获取资源2，而线程2有资源2的权限想要获取资源1.

避免的方法：1.锁越少越好，最好使用一把锁；2.调整好锁的顺序

9. 条件变量的使用及注意事项
定义：条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待条件变量的条件成立而挂起;另一个线程使条件成立（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥量结合在一起。

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);//阻塞等待一个条件变量
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);//限时等待一个条件变量
int pthread_cond_signal(pthread_cond_t *cond);//唤醒至少一个阻塞在条件变量上的线程
int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒全部阻塞在条件变量上的线程

使用步骤

1. 初始化：

静态初始化

pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化条件变量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //初始化互斥量

动态初始化

pthread_cond_init(&cond);

2. 生产资源线程

pthread_mutex_lock(&mutex);

开始产生资源

pthread_cond_sigal(&cond); //通知一个消费线程

或者

pthread_cond_broadcast(&cond); //广播通知多个消费线程

pthread_mutex_unlock(&mutex);

3. 消费者线程

pthread_mutex_lock(&mutex);

while （如果没有资源）{ //防止惊群效应

pthread_cond_wait(&cond, &mutex);

}

有资源了，消费资源

pthread_mutex_unlock(&mutex);

注意事项

pthread_cond_wait(&cond, &mutex)，在没有资源等待时是先unlock休眠，等资源到了，再lock所以pthread_cond_wait he pthread_mutex_lock 必须配对使用。
如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait ，则有可能会丢失信号。
pthead_cond_broadcast 信号会被多个线程收到，这叫线程的惊群效应。所以需要加上判断条件while循环。

10. 线程池及gdb调试多线程

概念：通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程集合
必要性：使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。
线程池的基本结构：1. 任务队列，存储需要处理的任务，由工作线程来处理这些任务；2. 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

线程池的实现

1. 创建线程池的基本结构：

任务队列链表

typedef struct Task;

线程池结构体

typedef struct ThreadPool;

2. 线程池的初始化：

pool_init()

{

创建一个线程池结构

实现任务队列互斥锁和条件变量的初始化

创建n个工作线程

}

3. 线程池添加任务

pool_add_task

{

判断是否有空闲的工作线程

给任务队列添加一个节点

给工作线程发送信号newtask

}

4. 实现工作线程

workThread

{

while(1){

   等待newtask任务信号

   从任务队列中删除节点

   执行任务

}

}

5. 线程池的销毁

pool_destory

{

删除任务队列链表所有节点，释放空间

删除所有的互斥锁条件变量

删除线程池，释放空间

}

线程的GDB调试

显示线程 info thread
切换线程 thread id
GDB为特定线程设置断点 break location thread id
GDB设置线程锁 set scheduler-locking on/off
on：其他线程会暂停。可以单独调试一个线程

11. 有名管道和无名管道

概念：就是进程和进程之间交换信息。
常用通信方式：无名管道（pipe）、有名管道（fifo）、信号（signal）、共享内存(mmap)、套接字（socket）
IPC通信方式：System V IPC、共享内存（share memory）、消息队列（message queue）、信号灯集（semaphore set）

无名管道

int pipe(int pfd[2]); 成功：0；失败：-1，设置errno

pfd[0] 为读描述符

pfd[1] 为写描述符

无名管道注意事项：

只能用于亲缘关系的进程间通信（父子进程，兄弟进程）

管道通信是单工的，一端读，一端写（程序实现设计好）。
数据自己读不能自己写
管道可以用于大于2个进程共享

无名管道的读写特性：

读管道：

1. 管道中有数据，read返回实际读到的字节数。

2. 管道中无数据：

(1) 管道写端被全部关闭，read返回0 (好像读到文件结尾)

(2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

写管道：

1. 管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)

2. 管道读端没有全部关闭：

(1) 管道已满，write阻塞。（管道大小64K）

(2) 管道未满，write将数据写入，并返回实际写入的字节数。

有名管道（命名管道）

创建管道

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char *filename, mode_t mode);

特点：

1. 有名管道可以使非亲缘的两个进程互相通信
2. 通过路径名来操作，在文件系统中可见，但内容存放在内存中
3. 文件IO来操作有名管道
4. 遵循先进先出规则
5. 不支持leek操作
6. 单工读写

open(const char *path, O_RDONLY);//1

open(const char *path, O_RDONLY | O_NONBLOCK);//2

open(const char *path, O_WRONLY);//3

open(const char *path, O_WRONLY | O_NONBLOCK);//4

注意事项：

1 就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递

2 第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的

3 对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

4.数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

12. 共享内存（内存映射的使用、注意事项、进程间通信、systemV共享内存）

概念：使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write。
mmap()的优点：实现了用户空间和内核空间的高效交互方式

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

功能：创建共享内存映射

函数返回值：成功返回创建的映射区首地址，失败返回MAP_FAILED（ ((void *) -1) ），设置errno值

参数说明：

addr：指定要映射的内存地址，一般设置为 NULL 让操作系统自动选择合适的内存地址。

length：必须>0。映射地址空间的字节数，它从被映射文件开头 offset 个字节开始算起。

prot：指定共享内存的访问权限。可取如下几个值的可选：PROT_READ（可读）, PROT_WRITE（可写）, PROT_EXEC（可执行）, PROT_NONE（不可访问）。

flags：由以下几个常值指定：MAP_SHARED（共享的） MAP_PRIVATE（私有的）, MAP_FIXED（表示必须使用 start 参数作为开始地址，如果失败不进行修正），其中，MAP_SHARED , MAP_PRIVATE必选其一，而 MAP_FIXED 则不推荐使用。MAP_ANONYMOUS（匿名映射，用于血缘关系进程间通信）

fd：表示要映射的文件句柄。如果匿名映射写-1。

offset：表示映射文件的偏移量，一般设置为 0 表示从文件头部开始映射。

注意事项：

（1）创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。

（2）当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)，如果不满足报非法参数（Invalid argument）错误。

当MAP_PRIVATE时候，mmap中的权限是对内存的限制，只需要文件有读权限即可，操作只在内存有效，不会写到物理磁盘，且不能在进程间共享。

（3）映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。

（4）用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）

（5）文件偏移量必须为0或者4K的整数倍（不是会报非法参数Invalid argument错误）.

（6）映射大小可以大于文件大小，但只能访问文件page的内存地址，否则报总线错误，超出映射的内存大小报段错误

（7）mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

mmap()映射的种类:1. 基于文件的映射;2. 匿名映射(适用于具有亲缘关系的进程之间)

释放内存映射

munmap函数

int munmap(void *addr, size_t length);

返回值：成功返回0，失败返回-1，并设置errno值。

函数参数：

addr：调用mmap函数成功返回的映射区首地址

length：映射区大小（即：mmap函数的第二个参数）

System V共享内存

ftok函数

key_t ftok(const char *path, int id);

其中参数path是指定的文件名，这个文件必须是存在的而且可以访问的。id是子序号，它是一个8bit的整数。即范围是0~255。当函数执行成功，则会返回key_t键值，否则返回-1。在一般的UNIX中，通常是将文件的索引节点取出，然后在前面加上子序号就得到key_t的值

system V 共享内存使用步骤：

1、创建/打开共享内存
2、映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
3 、读写共享内存
4、撤销共享内存映射
5、删除共享内存对象

查看共享内存命令ipcs

共享内存创建 – shmget

int shmget(key_t key, int size, int shmflg);

共享内存映射

void *shmat(int shmid, const void *shmaddr, int shmflg);

第二个参数一般写NULL，表示自动映射

第三参数一般写0 ，表示可读写

共享内存撤销

int shmdt(void *shmaddr);

撤销后，内存地址不可再访问。

共享内存控制

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmctl(shmid, IPC_RMID, NULL);删除共享内存

每块共享内存大小有限制 ipcs -l cat /proc/sys/kernel/shmmax
共享内存删除的时间点添加删除标记 nattach 变成0时真正删除

13. 信号机制上（信号概念、发送、定时器、信号捕捉、SIGCHLD）

定义：信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式 linux内核通过信号通知用户进程，不同的信号类型代表不同的事件 Linux对早期的unix信号机制进行了扩展
进程对信号有不同的响应方式：缺省方式忽略信号捕捉信号
信号的产生：按键产生、系统调用函数产生（比如raise， kill）、硬件异常命令行产生（kill）、软件条件（比如被0除，访问非法内存等）

信号名	含义	默认操作
SIGHUP	该信号在用户终端关闭时产生，通常是发给和该终端关联的会话内的所有进程	终止
SIGINT	该信号在用户键入INTR字符(Ctrl-C)时产生，内核发送此信号送到当前终端的所有前台进程	终止
SIGQUIT	该信号和SIGINT类似，但由QUIT字符(通常是 Ctrl-\)来产生	终止
SIGILL	该信号在一个进程企图执行一条非法指令时产生	终止
SIGSEV	该信号在非法访问内存时产生，如野指针、缓冲区溢出	终止
SIGPIPE	当进程往一个没有读端的管道中写入时产生，代表“管道断裂”	终止
SIGKILL	该信号用来结束进程，并且不能被捕捉和忽略	终止
SIGSTOP	该信号用于暂停进程，并且不能被捕捉和忽略	暂停进程
SIGTSTP	该信号用于暂停进程，用户可键入SUSP字符( 通常是Ctrl-Z)发出这个信号	暂停进程
SIGCONT	该信号让进程进入运行态	继续运行
SIGALRM	该信号用于通知进程定时器时间已到	终止
SIGUSR1/2	该信号保留给用户程序使用	终止
SIGCHLD	是子进程状态改变发给父进程的。	忽略

信号相关命令 kill / killall

kill [-signal] pid

默认发送SIGTERM

-sig 可指定信号

pid 指定发送对象

killall [-u user | prog]

prog 指定进程名

user 指定用户名

发信号函数

int kill（pid_t pid, int sig）

功能：发送信号

参数：

pid: > 0:发送信号给指定进程

        = 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。

        < -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。

        = -1：发送信号给，有权限发送的所有进程。

sig：待发送的信号

int raise(int sig);

功能：发送信号

参数：

sig:要发送的信号码。

给自己发信号，等价于kill(getpid(), signo);

定时器函数

unsigned int alarm(unsigned int seconds);

功能：定时发送SIGALRM给当前进程

参数： seconds：定时秒数

返回值：上次定时剩余时间。

ualarm （循环发送）

useconds_t ualarm(useconds_t usecs, useconds_t interval);

以useconds为单位，第一个参数为第一次产生时间，第二个参数为间隔产生

int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

功能：定时的发送alarm信号

参数：

which：

ITIMER_REAL：以逝去时间递减。发送SIGALRM信号

ITIMER_VIRTUAL: 计算进程（用户模式）执行的时间。发送SIGVTALRM信号

ITIMER_PROF: 进程在用户模式（即程序执行时）和核心模式（即进程调度用时）均计算时间。发送SIGPROF信号

new_value：  负责设定 timout 时间

old_value：   存放旧的timeout值，一般指定为NULL

struct itimerval {

        struct timeval it_interval; // 闹钟触发周期

        struct timeval it_value;    // 闹钟触发时间

};

struct timeval {

    time_t      tv_sec;         /* seconds */

    suseconds_t tv_usec;        /* microseconds */

};

信号的捕捉

信号捕捉过程：

定义新的信号的执行函数handle。
使用signal/sigaction 函数，把自定义的handle和指定的信号相关联。

signal函数：

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

功能：捕捉信号执行自定义函数

返回值：成功时返回原先的信号处理函数，失败时返回SIG_ERR

参数：

signo 要设置的信号类型

handler 指定的信号处理函数: SIG_DFL代表缺省方式; SIG_IGN 代表忽略信号;

系统建议使用sigaction函数，因为signal在不同类unix系统的行为不完全一样。

sigaction函数：

int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

参数：

signum：处理的信号

act,oldact: 处理信号的新行为和旧的行为，是一个sigaction结构体。

struct sigaction {

    void (*sa_handler)(int);

    void (*sa_sigaction)(int, siginfo_t *, void *);

    sigset_t sa_mask;

    int sa_flags;

    void (*sa_restorer)(void);

}

sigaction结构体成员定义如下：

sa_handler：是一个函数指针，其含义与 signal 函数中的信号处理函数类似

sa_sigaction：另一个信号处理函数，它有三个参数，可以获得关于信号的更详细的信息。

sa_flags参考值如下：

SA_SIGINFO：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数

SA_RESTART：使被信号打断的系统调用自动重新发起。

SA_RESETHAND：信号处理之后重新设置为默认的处理方式。

    SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。

re_restorer：是一个已经废弃的数据域

使用SIGCHLD信号实现回收子进程

子进程结束信号SIGCHLD的产生条件

1子进程终止时

2子进程接收到SIGSTOP信号停止时

3子进程处在停止态，接受到SIGCONT后唤醒时

14. 信号机制下（阻塞、信号集、信号驱动任务）

有时候不希望在接到信号时就立即停止当前执行，去处理信号，同时也不希望忽略该信号，而是延时一段时间去调用信号处理函数。这种情况可以通过阻塞信号实现。
信号的阻塞概念：信号的”阻塞“是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

信号的状态：

信号递达（Delivery ）：实际信号执行的处理过程(3种状态：忽略，执行默认动作，捕获)

信号未决（Pending）：从产生到递达之间的状态

信号集操作函数

sigset_t set; 自定义信号集。是一个32bit 64bit 128bit的数组。

sigemptyset(sigset_t *set); 清空信号集

sigfillset(sigset_t *set); 全部置1

sigaddset(sigset_t *set, int signum); 将一个信号添加到集合中

sigdelset(sigset_t *set, int signum); 将一个信号从集合中移除

sigismember（const sigset_t *set，int signum); 判断一个信号是否在集合中。

设定对信号集内的信号的处理方式(阻塞或不阻塞)

#include <signal.h>

int sigprocmask( int how, const sigset_t *restrict set, sigset_t *restrict oset );

返回值：若成功则返回0，若出错则返回-1

首先，若oset是非空指针，那么进程的当前信号屏蔽字通过oset返回。

其次，若set是一个非空指针，则参数how指示如何修改当前信号屏蔽字。

how可选用的值：（注意，不能阻塞SIGKILL和SIGSTOP信号）

SIG_BLOCK ：把参数set中的信号添加到信号屏蔽字中

SIG_UNBLOCK：从信号屏蔽字中删除参数set中的信号

SIG_SETMASK：把信号屏蔽字设置为参数set中的信号

int pause(void);

进程一直阻塞，直到被信号中断，返回值：-1 并设置errno为EINTR

函数行为：

1如果信号的默认处理动作是终止进程，则进程终止，pause函数么有机会返回。

2如果信号的默认处理动作是忽略，进程继续处于挂起状态，pause函数不返回

3 如果信号的处理动作是捕捉，则调用完信号处理函数之后，pause返回-1。

4 pause收到的信号如果被屏蔽，那么pause就不能被唤醒

int sigsuspend(const sigset_t *sigmask);

功能：将进程的屏蔽字替换为由参数sigmask给出的信号集，然后挂起进程的执行

参数：

sigmask：希望屏蔽的信号

15. 消息队列

消息队列是System V IPC对象的一种
消息队列由消息队列ID来唯一标识
消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等消息队列可以按照类型来发送/接收消息

消息队列结构

消息队列使用步骤

发送端：

1 申请Key

2打开/创建消息队列 msgget

3向消息队列发送消息 msgsnd

接收端：

1打开/创建消息队列 msgget

2从消息队列接收消息 msgrcv

3 控制（删除）消息队列 msgctl

16.信号灯（有名信号灯、无名信号灯、systemV信号灯）

信号量代表某一类资源，其值表示系统中该资源的数量
信号量是一个受保护的变量，只能通过三种操作来访问：初始化Ｐ操作(申请资源) Ｖ操作(释放资源)
三种信号灯：Posix 有名信号灯，Posix 无名信号灯（linux只支持线程同步），System V 信号灯

Ｐ(Ｓ) 含义如下:

     if (信号量的值大于0) {

申请资源的任务继续运行；

           信号量的值减一；

} else {

申请资源的任务阻塞；

}

V(Ｓ) 含义如下:

信号量的值加一；

if (有任务在等待资源) {

唤醒等待的任务，让其继续运行

}

Posix 有名信号灯和无名信号灯使用：

有名信号灯打开：

sem_t *sem_open(const char *name, int oflag);

sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

参数：

name：name是给信号灯起的名字

oflag：打开方式，常用O_CREAT

mode：文件权限。常用0666

value：信号量值。二元信号灯值为1，普通表示资源数目

信号灯文件位置：/dev/shm

有名信号灯关闭

int sem_close(sem_t *sem);

有名信号灯的删除

int sem_unlink(const char* name);

无名信号灯初始化

int sem_init(sem_t *sem, int shared, unsigned int value);

参数：

sem：需要初始化的信号灯变量

shared: shared指定为0，表示信号量只能由初始化这个信号量的进程使用，不能在进程间使用,linux 不支持进程间同步。

Value:信号量的值

无名信号灯销毁

int sem_destroy(sem_t* sem);

信号灯P操作

int sem_wait(sem_t *sem);

获取资源，如果信号量为0，表示这时没有相应资源空闲，那么调用线程就将挂起，直到有空闲资源可以获取

信号灯V操作

int sem_post(sem_t *sem);

释放资源，如果没有线程阻塞在该sem上，表示没有线程等待该资源，这时该函数就对信号量的值进行增1操作，表示同类资源多增加了一个。如果至少有一个线程阻塞在该sem上，表示有线程等待资源，信号量为0，这时该函数保持信号量为0不变，并使某个阻塞在该sem上的线程从sem_wait函数中返回

注意：编译posix信号灯需要加pthread动态库。

System V 信号灯使用：

int semget(key_t key, int nsems, int semflg);

功能：创建/打开信号灯

参数：key：ftok产生的key值（和信号灯关联的key值）

nsems：信号灯集中包含的信号灯数目

semflg：信号灯集的访问权限，通常为IPC_CREAT |0666

返回值：成功：信号灯集ID ；失败：-1

int semop ( int semid, struct sembuf *opsptr, size_t nops);

功能：对信号灯集合中的信号量进行P - V操作

参数：semid：信号灯集ID

struct sembuf {

short sem_num; // 要操作的信号灯的编号

short sem_op; // 1 : 释放资源，V操作

// -1 : 分配资源，P操作

short sem_flg; // 0（阻塞）,IPC_NOWAIT, SEM_UNDO

};//对某一个信号灯的操作，如果同时对多个操作，则需要定义这种结构体数组

nops: 要操作的信号灯的个数，1个

返回值：成功：0 ；失败：-1

int semctl ( int semid, int semnum, int cmd…/*union semun arg*/);

功能：信号灯集合的控制（初始化/删除）

参数：semid：信号灯集ID

semnum: 要操作的集合中的信号灯编号

cmd：

GETVAL：获取信号灯的值，返回值是获得值

SETVAL：设置信号灯的值，需要用到第四个参数：共用体

IPC_RMID：从系统中删除信号灯集合

返回值：成功 0 ；失败 -1