Linux-线程

一、线程

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

死锁
避免方法：

1. 锁越少越好，最好使用一把锁
2. 调整好锁的顺序

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] 为写描述符

无名管道注意事项：

1. 只能用于亲缘关系的进程间通信（父子进程，兄弟进程）
2. 管道通信是单工的，一端读，一端写（程序实现设计好）。
3. 数据自己读不能自己写
4. 管道可以用于大于2个进程共享

无名管道的读写特性：
① 读管道：

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

2. 管道中无数据：

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

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

② 写管道：

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

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

(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 */
};
信号的捕捉

信号捕捉过程：

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：是一个已经废弃的数据域

定时器的实现

使用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操作概念：
生产者和消费者场景
Ｐ(Ｓ) 含义如下:
if (信号量的值大于0) {
申请资源的任务继续运行；
信号量的值减一；
} else {
申请资源的任务阻塞；
}
V(Ｓ) 含义如下:
信号量的值加一；
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