一、线程
1.1、特点
- 通常线程指的是共享相同地址空间的多个任务
- 使用多线程的好处:
大大提高了任务切换的效率
避免了额外的TLB & cache的刷新
1.2、线程共享资源
- 一个进程中的多个线程共享以下资源:
可执行的指令
静态数据
进程中打开的文件描述符
当前工作目录
用户ID
用户组ID
1.3、线程私有资源
- 每个线程私有的资源包括:
线程ID (TID)
PC(程序计数器)和相关寄存器
堆栈
错误号 (errno)
优先级
执行状态和属性
1.4、线程库
- pthread线程库中提供了如下基本操作
创建线程
回收线程
结束线程 - 同步和互斥机制
信号量
互斥锁
二、线程创建
#include <pthread.h>
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine) (void *),
void *arg);
参数说明:
thread: 线程ID,是输出参数,创建成功后,系统将thread设置为线程ID
attr: 线程属性,使用pthread_attr_init和相关的函数进行初始化。如果该参数为NULL,则使用默认的属性创建线程
start_routine: 新线程执行的函数
arg: 新线程的函数参数
返回值:
成功返回0,失败返回错误号
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void *thread_fun(void *arg) {
printf("My pid is %d, my tid is %lu.\n", getpid(), *((unsigned long int *)arg));
return NULL;
}
int main() {
pthread_t tid;
printf("My pid is %d, my tid is %lu.\n", getpid(), pthread_self()); // pthread_self()用于获取当前线程的线程id
if (pthread_create(&tid, NULL, thread_fun, (void *)(&tid)) != 0) {
perror("pthread_create error");
exit(1);
}
sleep(1);
return 0;
}
三、线程回收
int pthread_join(pthread_t thread, void **retval);
作用:阻塞等待指定的线程终止,回收相应的资源。如果线程已经终止,则pthread_join立即返回。
参数说明:
thread: 线程ID
retval: 输出参数,用来保存线程的退出状态(比如调用pthread_exit()指定的退出值)。如果不需要获取退出状态时,可以使用NULL
返回值:
成功返回0,失败返回错误号
四、线程结束
4.1、主动退出
void pthread_exit(void *retval);
结束当前线程
retval可被其他线程通过pthread_join获取
线程结束,线程栈私有资源被释放
4.2、主动退出
int pthread_cancel(pthread_t thread);
作用:取消(结束)线程
参数说明:
thread: 线程ID
五、其他常用API
int pthread_attr_init(pthread_attr_t *attr);
作用:初始化属性
返回值:成功返回0, 失败返回错误号
int pthread_attr_destroy(pthread_attr_t *attr);
作用:销毁属性
返回值:成功返回0, 失败返回错误号
int pthread_attr_setdetachstate(pthread_attr_t *attr,int detachstate);
作用:将线程设置为分离状态
参数说明:
thread: 线程ID
返回值:成功返回0, 失败返回错误号
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
作用:获取分离状态信息
参数说明:
attr: 属性
detachstate:分离状态变量,传入参数。
0:不分离 1:分离
返回值:成功返回0,失败返回错误号
pthread_t pthread_self(void);
作用: 获取当前线程的ID
返回值:返回线程的ID
int pthread_detach(pthread_t thread);
作用: 将线程设置为分离状态
参数说明:
thread: 线程ID
返回值:成功返回0,失败返回错误号
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
作用:初始化条件变量
#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
销毁条件变量
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void *thread1_fun(void *arg) {
pthread_exit(NULL);
}
void *thread2_fun(void *arg) {
char *msg = (char *) malloc(10);
strcpy(msg, "Message.");
sleep(1);
pthread_exit((void *) msg);
}
int main() {
pthread_t tid1, tid2;
if (pthread_create(&tid1, NULL, thread1_fun, NULL) != 0) {
perror("pthread_create error");
exit(1);
}
if (pthread_create(&tid2, NULL, thread2_fun, NULL) != 0) {
perror("pthread_create error");
exit(1);
}
pthread_detach(tid1); // 将子线程转换为分离态,由系统自动回收资源
void *ret;
pthread_join(tid2, &ret); // 等待子线程的结束,在其结束后回收其资源
printf("%s\n", (char *) ret);
free(ret);
return 0;
}
5.1、例子
5.1.1、变量参数
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *thread_func(void *arg)
{
pthread_t tid = 0;
long thread_number = -1;
thread_number = (long)arg;
tid = pthread_self();
printf("tid:%ld, number:%ld\n", tid, thread_number);
while (1) {
printf("I am sub pthread, thread number:%ld\n", thread_number);
sleep(1);
}
}
int main(int argc, char *argv[])
{
int ret = 0;
long i = 0;
pthread_t tid = 0;
pthread_t main_tid = 0;
for (i = 0; i < 3; i++) {
ret = pthread_create(&tid, NULL, thread_func, (void *)i);
}
while (1) {
printf("I am main thread\n");
sleep(1);
}
return 0;
}
5.1.2、结构体参数
#include <stdio.h>
#include <string.h>
#include <pthread.h>
typedef struct thread_info_s
{
int number;
char name[32];
} thread_info_t;
thread_info_t g_thread_info;
void *thread_func(void *arg)
{
pthread_t tid = 0;
thread_info_t *thread_info = NULL;
thread_info = (thread_info_t *)arg;
tid = pthread_self();
printf("tid:%ld, name:%s, number:%d\n",
tid, thread_info->name, thread_info->number);
while (1) {
sleep(1);
}
}
int main(int argc, char *argv[])
{
int ret = 0;
pthread_t tid = 0;
pthread_t main_tid = 0;
g_thread_info.number = 1;
strcpy(g_thread_info.name, "test-thread");
ret = pthread_create(&tid, NULL, thread_func, (void *)&g_thread_info);
while (1) {
sleep(1);
}
return 0;
}
5.1.3、线程的退出值及分离属性-退出值为字符串
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *thread_func(void *arg)
{
pthread_t tid = 0;
tid = pthread_self();
printf("sub tid:%ld\n", tid);
sleep(3);
pthread_exit((void *)"hello world");
}
int main(int argc, char *argv[])
{
int ret = 0;
pthread_t tid = 0;
void *exit_value = NULL;
ret = pthread_create(&tid, NULL, thread_func, NULL);
pthread_join(tid, (void **)(&exit_value));
printf("thread exit value:%s\n", (char *)exit_value);
return 0;
}
5.1.4、线程的退出值及分离属性-退出值为整型
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *thread_func(void *arg)
{
pthread_t tid = 0;
static int exit_value = 5;
tid = pthread_self();
printf("sub tid:%ld\n", tid);
sleep(3);
pthread_exit((void *)&exit_value);
}
int main(int argc, char *argv[])
{
int ret = 0;
pthread_t tid = 0;
int *exit_value = NULL;
ret = pthread_create(&tid, NULL, thread_func, NULL);
pthread_join(tid, (void **)(&exit_value));
printf("thread exit value:%d\n", *exit_value);
return 0;
}
5.1.5、线程的退出值及分离属性-线程分离状态时
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *thread_func(void *arg)
{
pthread_t tid = 0;
tid = pthread_self();
printf("sub tid:%ld\n", tid);
sleep(10);
pthread_exit((void *)"hello world");
}
int main(int argc, char *argv[])
{
int ret = 0;
pthread_t tid = 0;
void *exit_value = NULL;
pthread_attr_t thread_attr;
int detachstate = 1;
pthread_attr_init(&thread_attr);
pthread_attr_setdetachstate(&thread_attr, detachstate);
ret = pthread_create(&tid, &thread_attr, thread_func, NULL);
pthread_join(tid, (void **)(&exit_value));
printf("thread exit value:%s\n", (char *)exit_value);
pthread_attr_destroy(&thread_attr);
while (1) {
sleep(2);
}
return 0;
}
六、同步与互斥
6.1、概念
6.1.1、同步
是指散布在不同任务之间的若干程序片断,它们的运行必须严格按照规定的某种先后次序来运行,这种先后次序依赖于要完成的特定的任务。最基本的场景就是:两个或两个以上的进程或线程在运
6.1.2、互斥
行过程中协同步调,按预定的先后次序运行。
是指散布在不同任务之间的若干程序片断,当某个任务运行其中一个程序片段时,其它任务就不能运行它们之中的任一程序片段,只能等到该任务运行完这个程序片段后才可以运行。最基本的场景就是:一个公共资源同一时刻只能被一个进程或线程使用,多个进程或线程不能同时使用公共资源
- 临界资源
一次只允许一个任务(进程、线程)访问的共享资源 - 临界区
访问临界区的代码 - 互斥机制
mutex互斥锁——只能有一个任务可以获得
任务访问临界区前申请锁,访问完后释放锁
6.2、互斥锁
6.2.1、互斥锁初始化
#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_t* attr);
成功时返回0,失败时返回错误码
mutex指向初始化的互斥锁对象
attr互斥锁属性,NULL表示缺省属性(一般情况就是NULL)
动态方式:
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
其中mutexattr用于指定互斥锁属性,如果为NULL则使用缺省属性。
静态方式:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
6.2.2、申请锁
#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
成功时返回0,失败时返回错误码
mutex指向初始化的互斥锁对象
如果无法获得锁,任务阻塞
6.2.3、释放锁
#include<pthread.h>
int pthread_mutex_unclock(pthread_mutex_t *mutex);
成功时返回0,失败时返回错误码
mutex指向要初始化的互斥锁对象
执行完临界区要及时释放锁
6.2.4、销毁锁
int pthread_mutex_destroy(pthread_mutex_t *mutex)
在Linux中,互斥锁并不占用任何资源,因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外(锁定状态则返回EBUSY)没有其他动作。
6.2.5、互斥锁的使用
int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_unlock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)
6.2.6、例子
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
unsigned int count,value1,value2;
pthread_mutex_t lock;
void *funtion(void *arg);
int main()
{
pthread_t a_thread;
if(pthread_mutex_init(&lock,NULL)!=0){//锁初始化,默认属性,只需要初始化一次
printf("fail to pthread_mutex_init\n");
exit(-1);
}
if(pthread_create(&a_thread,NULL,funtion,NULL)!=0){//创建线程
printf("fail to pthread_create");
exit(-1);
}
while(1){
count++;
#ifdef _LOCK_//条件编译
pthread_mutex_lock(&lock);
#endif
value1=count;
value2=count;
#ifdef _LOCK_
pthread_mutex_unlock(&lock);
#endif
}
return 0;
}
void *funtion(void *arg)
{
while(1){
#ifdef _LOCK_
pthread_mutex_lock(&lock);
#endif
if(value1!=value2){
printf("value1=%u,value2=%u\n",value1,value2);
usleep(100000);
}
#ifdef _LOCK_
pthread_mutex_unlock(&lock);
#endif
}
return NULL;
}
6.3、读写锁
特性:
写者:写者使用写锁,如果当前没有读者,也没有其他写者,写者立即获得写锁;否则写者将等待,直到没有读者和写者。
读者:读者使用读锁,如果当前没有写者,读者立即获得读锁;否则读者等待,直到没有写者。
注意:
同一时刻只有一个线程可以获得写锁,同一时刻可以有多个线程获得读锁。
读写锁出于写锁状态时,所有试图对读写锁加锁的线程,不管是读者试图加读锁,还是写者试图加写锁,都会被阻塞。
读写锁处于读锁状态时,有写者试图加写锁时,之后的其他线程的读锁请求会被阻塞,以避免写者长时间的不写锁
初始化一个读写锁 pthread_rwlock_init
读锁定读写锁 pthread_rwlock_rdlock
非阻塞读锁定 pthread_rwlock_tryrdlock
写锁定读写锁 pthread_rwlock_wrlock
非阻塞写锁定 pthread_rwlock_trywrlock
解锁读写锁 pthread_rwlock_unlock
释放读写锁 pthread_rwlock_destroy
死锁
避免方法:
- 锁越少越好,最好使用一把锁
- 调整好锁的顺序
6.4、条件变量
应用场景:生产者消费者问题,是线程同步的一种手段。
必要性:为了实现等待某个资源,让线程休眠。提高运行效率
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);
注意:
1、pthread_cond_wait(&cond, &mutex),在没有资源等待是是先unlock 休眠,等资源到了,再lock,所以pthread_cond_wait he pthread_mutex_lock 必须配对使用。
2、如果pthread_cond_signal或者pthread_cond_broadcast 早于 pthread_cond_wait ,则有可能会丢失信号。
3、pthead_cond_broadcast 信号会被多个线程收到,这叫线程的惊群效应。所以需要加上判断条件while循环。
七、线程池
7.1、概念:
通俗的讲就是一个线程的池子,可以循环的完成任务的一组线程集合
7.2、概念必要性:
我们平时创建一个线程,完成某一个任务,等待线程的退出。但当需要创建大量的线程时,假设T1为创建线程时间,T2为在线程任务执行时间,T3为线程销毁时间,当 T1+T3 > T2,这时候就不划算了,使用线程池可以降低频繁创建和销毁线程所带来的开销,任务处理时间比较短的时候这个好处非常显著。
7.3、概念线程池的基本结构:
1 任务队列,存储需要处理的任务,由工作线程来处理这些任务
2 线程池工作线程,它是任务队列任务的消费者,等待新任务的信号
7.4、
线程池的实现:
1创建线程池的基本结构:
任务队列链表
typedef struct Task;
线程池结构体
typedef struct ThreadPool;
2. 线程池的初始化:
pool_init()
{
创建一个线程池结构
实现任务队列互斥锁和条件变量的初始化
创建n个工作线程
}
3. 线程池添加任务
pool_add_task
{
判断是否有空闲的工作线程
给任务队列添加一个节点
给工作线程发送信号newtask
}
4. 实现工作线程
workThread
{
while(1){
等待newtask任务信号
从任务队列中删除节点
执行任务
}
}
5. 线程池的销毁
pool_destory
{
删除任务队列链表所有节点,释放空间
删除所有的互斥锁条件变量
删除线程池,释放空间
}
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define POOL_NUM 10
typedef struct Task{
void *(*func)(void *arg);
void *arg;
struct Task *next;
}Task;
typedef struct ThreadPool{
pthread_mutex_t taskLock;
pthread_cond_t newTask;
pthread_t tid[POOL_NUM];
Task *queue_head;
int busywork;
}ThreadPool;
ThreadPool *pool;
void *workThread(void *arg){
while(1){
pthread_mutex_lock(&pool->taskLock);
pthread_cond_wait(&pool->newTask,&pool->taskLock);
Task *ptask = pool->queue_head;
pool->queue_head = pool->queue_head->next;
pthread_mutex_unlock(&pool->taskLock);
ptask->func(ptask->arg);
pool->busywork--;
}
}
void *realwork(void *arg){
printf("Finish work %d\n",(int)arg);
}
void pool_add_task(int arg){
Task *newTask;
pthread_mutex_lock(&pool->taskLock);
while(pool->busywork>=POOL_NUM){
pthread_mutex_unlock(&pool->taskLock);
usleep(10000);
pthread_mutex_lock(&pool->taskLock);
}
pthread_mutex_unlock(&pool->taskLock);
newTask = malloc(sizeof(Task));
newTask->func = realwork;
newTask->arg = arg;
pthread_mutex_lock(&pool->taskLock);
Task *member = pool->queue_head;
if(member==NULL){
pool->queue_head = newTask;
}else{
while(member->next!=NULL){
member=member->next;
}
member->next = newTask;
}
pool->busywork++;
pthread_cond_signal(&pool->newTask);
pthread_mutex_unlock(&pool->taskLock);
}
void pool_init(){
pool = malloc(sizeof(ThreadPool));
pthread_mutex_init(&pool->taskLock,NULL);
pthread_cond_init(&pool->newTask,NULL);
pool->queue_head = NULL;
pool->busywork=0;
for(int i=0;i<POOL_NUM;i++){
pthread_create(&pool->tid[i],NULL,workThread,NULL);
}
}
void pool_destory(){
Task *head;
while(pool->queue_head!=NULL){
head = pool->queue_head;
pool->queue_head = pool->queue_head->next;
free(head);
}
pthread_mutex_destroy(&pool->taskLock);
pthread_cond_destroy(&pool->newTask);
free(pool);
}
int main(){
pool_init();
sleep(20);
for(int i=1;i<=20;i++){
pool_add_task(i);
}
sleep(5);
pool_destory();
}
八、线程的GDB调试:
显示线程
info thread
切换线程
thread id
GDB为特定线程设置断点
break location thread id
GDB设置线程锁,
set scheduler-locking on/off
on:其他线程会暂停。可以单独调试一个线程
九、进程间通信
概念:就是进程和进程之间交换信息。
常用通信方式:
无名管道(pipe)
有名管道 (fifo)
信号(signal)
共享内存(mmap)
套接字(socket)
过时的IPC通信方式:
System V IPC
共享内存(share memory)
消息队列(message queue)
信号灯集(semaphore set)
9.1、无名管道
int pipe(int pfd[2]); 成功:0;失败:-1,设置errno
pfd[0] 为读描述符
pfd[1] 为写描述符
无名管道注意事项:
- 只能用于亲缘关系的进程间通信(父子进程,兄弟进程)
- 管道通信是单工的,一端读,一端写(程序实现设计好)。
- 数据自己读不能自己写
- 管道可以用于大于2个进程共享
无名管道的读写特性:
① 读管道:
-
管道中有数据,read返回实际读到的字节数。
-
管道中无数据:
(1) 管道写端被全部关闭,read返回0 (好像读到文件结尾)
(2) 写端没有全部被关闭,read阻塞等待(不久的将来可能有数据递达,此时会让出cpu)
② 写管道:
-
管道读端全部被关闭, 进程异常终止(也可使用捕捉SIGPIPE信号,使进程不终止)
-
管道读端没有全部关闭:
(1) 管道已满,write阻塞。(管道大小64K)
(2) 管道未满,write将数据写入,并返回实际写入的字节数。
9.2、有名管道
创建管道
#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),那么或者写入全部字节,或者一个字节都不写入,系统就可以确保数据决不会交错在一起。
9.3、信号机制
概念:信号是在软件层次上对中断机制的一种模拟,是一种异步通信方式
所有信号的产生及处理全部都是由内核完成的
信号的产生:
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 */
};
信号的捕捉
信号捕捉过程:
- 定义新的信号的执行函数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);
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:是一个已经废弃的数据域
定时器的实现
使用SIGCHLD信号实现回收子进程
SIGCHLD的产生条件
1子进程终止时
2子进程接收到SIGSTOP信号停止时
3子进程处在停止态,接受到SIGCONT后唤醒时
信号集、信号的阻塞
目的:不希望在接到信号时就立即停止当前执行,去处理信号,同时也不希望忽略该信号,而是延时一段时间去调用信号处理函数。这种情况可以通过阻塞信号实现。
信号的阻塞概念:信号的”阻塞“是一个开关动作,指的是阻止信号被处理,但不是阻止信号产生。
信号的状态:
信号递达(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:希望屏蔽的信号
9.4、消息队列
概念:
消息队列是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 存放消息队列属性的地址
9.5、信号灯/信号量(semaphore)
概念:是不同进程间或一个给定进程内部不同线程间同步的机制。类似我们的
PV操作概念:
生产者和消费者场景
P(S) 含义如下:
if (信号量的值大于0) {
申请资源的任务继续运行;
信号量的值减一;
} else {
申请资源的任务阻塞;
}
V(S) 含义如下:
信号量的值加一;
if (有任务在等待资源) {
唤醒等待的任务,让其继续运行
}
三种信号灯:
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