并发程序设计笔记

Day1 进程的创建和回收

程序：存放在磁盘上的指令和数据的有序集合（文件）是静态的

进程：执行一个程序所分配的资源的总称是动态的

进程类型：交互进程、批处理进程、守护进程

进程状态：运行态、等待态、停止态、死亡态

查看进程信息命令

ps     查看系统进程快照   -e：显示所有进程   -l：长格式显示更加详细的信息  -f 全部列出，通常和其他选项联用

top    查看进程动态信息    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程序后台运行

子进程概念：

#include  <unistd.h>

 pid_t  fork(void);

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

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

通过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  <unistd.h>

  pid_t wait(int *status);

 成功时返回回收的子进程的进程号；失败时返回EOF

 若子进程没有结束，父进程一直阻塞

 若有多个子进程，哪个先结束就先回收

 status 指定保存子进程返回值和结束方式的地址

 status为NULL表示直接释放子进程PCB,不接收返回值

#include  <unistd.h>

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

pid：

pid>0时，只等待进程ID等于pid的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束，waitpid就会一直等下去。

pid=-1时，等待任何一个子进程退出，没有任何限制，此时waitpid和wait的作用一模一样。

pid=0时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会对它做任何理睬。

pid<-1时，等待一个指定进程组中的任何子进程，这个进程组的ID等于pid的绝对值。

options：

options提供了一些额外的选项来控制waitpid，目前在Linux中只支持WNOHANG和WUNTRACED两个选项，这是两个常数，可以用"|"运算符把它们连接起来使用

WNOHANG ：若由pid指定的子进程未发生状态改变(没有结束)，则waitpid()不阻塞，立即返回0

WUNTRACED： 返回终止子进程信息和因信号停止的子进程信息

 wait(wait_stat) 等价于waitpid(-1,wait_stat,0)

Day2 exec 函数族

exec 函数族

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

作用：执行指定的程序

#include  <unistd.h>

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

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

 成功时执行指定的程序；失败时返回EOF

 path   执行的程序名称，包含路径

 arg…  传递给执行的程序的参数列表

 file   执行的程序的名称，在PATH中查找

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

Day3 守护进程

概念：守护进程又叫精灵进程（Daemon Process），它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。

特点：始终在后台运行，独立于任何终端，周期性的执行某种任务或等待处理特定事件。

它是个特殊的孤儿进程，这种进程脱离终端，为什么要脱离终端呢？之所以脱离于终端是为了避免进程被任何终端所产生的信息所打断，其在执行过程中的信息也不在任何终端上显示。由于在 Linux 中，每一个系统与用户进行交流的界面称为终端，每一个从此终端开始运行的进程都会依附于这个终端，这个终端就称为这些进程的控制终端，当控制终端被关闭时，相应的进程都会自动关闭。

举例：http 服务的守护进程叫 httpd，mysql 服务的守护进程叫 mysqld

更简便地创建守护进程： 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

Day4 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调试的进程

Day5 线程的创建和参数传递

线程的创建

 #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 * ，注意传递参数格式

注意事项：主进程的退出，它创建的线程也会退出、线程创建需要时间，如果主进程马上退出，那线程不能得到执行、通过地址传递参数，注意类型的转换、值传递，这时候编译器会告警，需要程序员自己保证数据长度正确

获取线程的id：通过pthread_create函数的第一个参数、通过在线程里面调用pthread_self函数

Day6 线程的回收及内存演示

线程的回收

使用pthread_join 函数：

#include  <pthread.h>

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

注意：pthread_join 是阻塞函数，如果回收的线程没有结束，则一直等待

使用线程的分离：

1 使用pthread_detach

2 创建线程时候设置为分离属性

  pthread_attr_t attr;

  pthread_attr_init(&attr);

  pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

Day7 线程的取消和清理

线程的取消：

意义：随时杀掉一个线程

int pthread_cancel(pthread_t thread);

注意：线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用

使用gdb调试错误流程：

使用gdb 运行代码，gdb  ./ 名称

(gdb) run

等待出现Thread 1 "pcancel" received signal SIGSEGV, Segmentation fault.

输入命令bt（打印调用栈）

(gdb) bt

#0  0x00007ffff783ecd0 in vfprintf () from /lib/x86_64-linux-gnu/libc.so.6

#1  0x00007ffff78458a9 in printf () from /lib/x86_64-linux-gnu/libc.so.6

#2  0x00000000004007f9 in main () at pcancel.c:21

确定段错误位置是pcancel.c 21行

设置线程取消属性

int pthread_setcanceltype(int type, int *oldtype);

PTHREAD_CANCEL_DEFERRED                等到取消点才取消

PTHREAD_CANCEL_ASYNCHRONOUS           目标线程会立即取消

如果没有取消点，手动设置一个

void pthread_testcancel(void);

线程的清理

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

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

void pthread_cleanup_pop(int execute)

routine 函数被执行的条件：

1. 被pthread_cancel取消掉。
2. 执行pthread_exit
3. 非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退出线程。

Day8 互斥锁/读写锁的概念及使用 

线程的互斥和同步

临界资源概念：

不能同时访问的资源、临界资源不可以共享，比如写文件，只能由一个线程写，同时写会写乱。

比如外设打印机，打印的时候只能由一个程序使用。

外设基本上都是不能共享的资源。

生活中比如卫生间，同一时间只能由一个人使用。

创建互斥锁：

动态创建：

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

其中mutexattr用于指定互斥锁属性，如果为NULL则使用缺省属性。

静态创建：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

锁的销毁：

int pthread_mutex_destroy(pthread_mutex_t *mutex)

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

互斥锁的使用：

int pthread_mutex_lock(pthread_mutex_t *mutex)

int pthread_mutex_unlock(pthread_mutex_t *mutex)

int pthread_mutex_trylock(pthread_mutex_t *mutex)

读写锁：

写：写者使用写锁，如果当前没有读者，也没有其他写者，写者立即获得写锁；否则写者将等待，直到没有读者和写者。

读：读者使用读锁，如果当前没有写者，读者立即获得读锁；否则读者等待，直到没有写者。

注意：同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

初始化一个读写锁   pthread_rwlock_init

读锁定读写锁       pthread_rwlock_rdlock

非阻塞读锁定　　   pthread_rwlock_tryrdlock

写锁定读写锁      pthread_rwlock_wrlock

非阻塞写锁定      pthread_rwlock_trywrlock

解锁读写锁         pthread_rwlock_unlock

释放读写锁         pthread_rwlock_destroy

死锁：

为了避免产生死锁，可以采取：只使用一把锁，或者调整多把锁生效的顺序

 

Day9 条件变量的使用及注意事项  

使用目的：为了实现等待某个资源，让线程休眠。提高运行效率

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);

使用步骤：

初始化：

静态初始化

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

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

动态初始化

pthread_cond_init(&cond);

生产资源线程：

pthread_mutex_lock(&mutex);

开始产生资源

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

或者

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

pthread_mutex_unlock(&mutex);

消费者线程：

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循环。

 

Day10 线程池及gdb调试多线程  

就是一个线程的池子，可以循环的完成任务的一组线程集合，建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时，假设T1为创建线程时间，T2为在线程任务执行时间，T3为线程销毁时间，当 T1+T3 > T2，这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著。

线程池的基本结构：

任务队列，存储需要处理的任务，由工作线程来处理这些任务

 线程池工作线程，它是任务队列任务的消费者，等待新任务的信号

线程池的实现：

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：其他线程会暂停。可以单独调试一个线程

 

Day11 有名管道和无名管道  

进程间通信（IPC，InterProcess Communication），就是进程和进程之间交换信息。常用通信方式：无名管道（pipe）、有名管道 （fifo）、信号（signal）、共享内存(mmap)、套接字（socket）

无名管道

int pipe(int pfd[2]); 成功：0；失败：-1，设置errno、pfd[0] 为读描述符、pfd[1] 为写描述符

无名管道注意事项：

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

管道通信是单工的，一端读，一端写（程序实现设计好）

数据自己读不能自己写

管道可以用于大于2个进程共享

无名管道的读写特性：

• 读管道：

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

2. 管道中无数据：

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

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

• 写管道：

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

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

管道已满：write阻塞。（管道大小64K）

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

有名管道（命名管道）

创建管道

#include <sys/types.h>

#include <sys/stat.h>

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





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有名管道可以使非亲缘的两个进程互相通信

2通过路径名来操作，在文件系统中可见，但内容存放在内存中

3 文件IO来操作有名管道

4 遵循先进先出规则

5 不支持leek操作

6 单工读写

注意事项：

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），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

Day12 共享内存

使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write

优点：

实现了用户空间和内核空间的高效交互方式

函数定义：

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 共享内存

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);删除共享内存

Day13 信号机制上

信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式 ，所有信号的产生及处理全部都是由内核完成的

信号的产生：

1 按键产生、2 系统调用函数产生（比如raise， kill）、3 硬件异常、4 命令行产生 （kill）、5 软件条件（比如被0除，访问非法内存等）

信号处理方式：

1 缺省方式、2 忽略信号、3 捕捉信号

常用信号：

信号名	含义	默认操作
SIGHUP	该信号在用户终端关闭时产生，通常是发给和该 终端关联的会话内的所有进程	终止
SIGINT	该信号在用户键入INTR字符(Ctrl-C)时产生，内 核发送此信号送到当前终端的所有前台进程	终止
SIGQUIT	该信号和SIGINT类似，但由QUIT字符(通常是 Ctrl-\)来产生	终止
SIGILL	该信号在一个进程企图执行一条非法指令时产生	终止
SIGSEV	该信号在非法访问内存时产生，如野指针、缓 冲区溢出	终止
SIGPIPE	当进程往一个没有读端的管道中写入时产生，代 表“管道断裂”	终止

信号名	含义	默认操作
SIGKILL	该信号用来结束进程，并且不能被捕捉和忽略	终止
SIGSTOP	该信号用于暂停进程，并且不能被捕捉和忽略	暂停进程
SIGTSTP	该信号用于暂停进程，用户可键入SUSP字符( 通常是Ctrl-Z)发出这个信号	暂停进程
SIGCONT	该信号让进程进入运行态	继续运行
SIGALRM	该信号用于通知进程定时器时间已到	终止
SIGUSR1/2	该信号保留给用户程序使用	终止
SIGCHLD	是子进程状态改变发给父进程的。	忽略

信号命令：

kill [-signal] pid

killall [-u  user | prog]

信号的函数：

int kill（pid_t pid, int signum）

功能：发送信号

参数：

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

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

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

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

                  signum：待发送的信号

int  raise(int 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 */

};

 

Day14 信号机制下  

信号的捕捉

信号捕捉过程：

1. 定义新的信号的执行函数handle。
2. 使用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);

struct sigaction {

    void (*sa_handler)(int);

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

    sigset_t sa_mask;

    int sa_flags;

    void (*sa_restorer)(void);

}

参数：

signum：处理的信号

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

sigaction结构体成员定义如下：

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

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

sa_flags参考值如下：

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

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

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

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

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

信号的阻塞概念：信号的”阻塞“是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

信号的状态：

信号递达（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：希望屏蔽的信号

 

Day15 消息队列

消息队列是System V IPC对象的一种

消息队列的使用：

发送端：

1 申请Key

2打开/创建消息队列   msgget

3向消息队列发送消息   msgsnd

接收端：

1打开/创建消息队列   msgget

2从消息队列接收消息   msgrcv

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

打开/创建消息队列

 #include <sys/ipc.h>

 #include <sys/msg.h>

 int msgget(key_t key, int msgflg);

  成功时返回消息队列的id，失败时返回EOF

  key 和消息队列关联的key  IPC_PRIVATE 或 ftok

  msgflg  标志位  IPC_CREAT|0666  IPC_CREAT：没有创建，有则打开。

发送消息

#include <sys/ipc.h>

 #include <sys/msg.h>

 int msgsnd(int msgid, const void *msgp, size_t size,

            int msgflg);



  成功时返回0，失败时返回-1

  msgid   消息队列id

  msgp    消息缓冲区地址

  size    消息正文长度

  msgflg   标志位 0 或 IPC_NOWAIT

msgflg:

0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列

IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回

消息格式：

typedef struct{

long msg_type;

char buf[128];

}msgT;

注意：

1 消息结构必须有long类型的msg_type字段，表示消息的类型

2消息长度不包括首类型 long

消息的接收：

#include <sys/ipc.h>

 #include <sys/msg.h>

 int msgrcv(int msgid, void *msgp, size_t size, long msgtype,

                   int msgflg);



  成功时返回收到的消息长度，失败时返回-1

  msgid   消息队列id

  msgp   消息缓冲区地址

  size   指定接收的消息长度

  msgtype   指定接收的消息类型  

  msgflg   标志位 

msgtype：

msgtype=0：收到的第一条消息，任意类型。

msgtype>0：收到的第一条 msg_type类型的消息。

msgtype<0：接收类型等于或者小于msgtype绝对值的第一个消息。

例子：如果msgtype=-4，只接受类型是1、2、3、4的消息

 

msgflg：

0：阻塞式接收消息

IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG

MSG_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息

消息队列的控制

#include <sys/ipc.h>

 #include <sys/msg.h>

 int msgctl(int msgid, int cmd, struct msqid_ds *buf);

  成功时返回0，失败时返回-1

  msgid    消息队列id

  cmd    要执行的操作  IPC_STAT / IPC_SET / IPC_RMID（删除）

  buf   存放消息队列属性的地址

 

Day16 信号灯

三种信号灯：

Posix 有名信号灯

Posix 无名信号灯 （linux只支持线程同步）

System V 信号灯

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