Linux编程信号处理

====信号处理====
#include <signal.h>
int sigaction(int sig, const struct sigaction *act,
    struct sigaction *oldact);
设置信号处理函数，比signal函数更安全可靠

#include <signal.h>
int kill(pid_t pid, int sig);
发送信号给pid的进程，一般测试进程存在，可以发送0信号
返回0成功，－1失败

#include <signal.h>
int raise(int sig);
发送一个信号给进程自身，返回0成功，非0错误

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int sig);
int sigdelset(sigset_t *set, int sig);
清空、填满、添加、删除信号集合，返回0成功，－1失败

#include <signal.h>
int sigismember(const sigset_t *set, int sig);
测试sig信号是否在set信号集合里面，返回1表示存在，0不存在

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
设置信号掩码，返回0成功，－1失败

#include <unistd.h>
int pause(void);
暂停程序，知道程序接受到任意信号中断它，永远返回－1
并设置errno为EINTR

#include <stdlib.h>
void abort(void);
退出程序，生成coredump

====定时器和休眠====
#include <sys/time.h>
int setitimer(int which, const struct itimerval *new_value,
    struct itimerval *old_value);
设置一个超时，并发出特定信号给进程自己
which的值如下：
ITIMER_REAL     墙上的时间为准，超时发送SIGALRM信号给自己
ITIMER_VIRTUAL  程序的用户时间为准，超时发送SIGVTALRM信号给自己
ITIMER_PROF     程序运行时间为准(CPU & USER)，超时发送SIGPROF给自己

#include <sys/time.h>
int getitimer(int which, struct itimerval *curr_value);
获取上面函数设置的which定时器的状态，返回0表示正常，－1表示已经超时

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
在seconds秒后发送SIGALARM信号，成功返回前一次设置剩余的超时秒数
返回0表示前一次没有任何设置，永远成功

#include <unistd.h>
unsigned int sleep(unsigned int seconds);
睡眠seconds秒，返回0表示完成，或是已经睡眠了多少秒(被中断)

#define _POSIX_C_SOURCE 199309
#include <signal.h>
#include <time.h>
int timer_create(clockid_t clockid, struct sigevent *evp, timer_t *timerid);
创建一个定时器，返回0成功，-1失败

define _POSIX_C_SOURCE 199309
#include <time.h>
int timer_settime(timer_t timerid, int flags,
    const struct itimerspec *value, struct itimerspec *old_value);
初始化定时器，返回0成功，－1失败

#define _POSIX_C_SOURCE 199309
#include <time.h>
int timer_gettime(timer_t timerid, struct itimerspec *curr_value);
获取定时器信息，返回0成功，-1失败

#define _POSIX_C_SOURCE 199309
#include <time.h>
int timer_delete(timer_t timerid);
删除定时器，成功返回0，失败－1值

====进程====
#include <unistd.h>
pid_t fork(void);
创建一个进程，错误返回－1，成功父进程返回子进程的ID号，子进程
返回0值

include <unistd.h>
void _exit(int status);
退出进程

#include <stdlib.h>
void exit(int status)
退出程序，执行如下清理：
1.如果注册了exit handlers，首先调用它们
2.清理IO相关的缓冲内存
3.调用_exit函数，使用status的值作为返回状态
status的值最好使用0-255的值，因为历史原因，退出的值
是16位（2字节）构成，高8位表示程序退出的值，低8位表示程序退出的信号

#include <stdlib.h>
int atexit(void (*func)(void));
注册exit handler函数，成功返回0，-1出错

#include <sys/wait.h>
pid_t wait(int *status);
1.阻塞直到子进程结束
2.子进程返回值写入status(不为NULL的时候)
3.统计所有子进程的资源使用情况
4.返回子进程的ID号
返回－1表示出错

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
1.pid > 0，等待pid号子进程
2.pid == 0,等待同一个进程组ID等于父进程的进程
3.pid < -1,等待同一个进程组ID等于pid绝对值的进程
4.pid == -1, 等待所有子进程

#include <unistd.h>
int execve(const char *pathname, char *const argv[], char *const envp[]);
int execle(const char *pathname, const char *arg, ...
    /* , (char *) NULL, char *const envp[] */ );
int execlp(const char *filename, const char *arg, ... /* , (char *) NULL */);
int execvp(const char *filename, char *const argv[]);
int execv(const char *pathname, char *const argv[]);
int execl(const char *pathname, const char *arg, ...
    /* , (char *) NULL */);
成功永不返回，返回－1表示出错

#include <stdlib.h>
int system(const char *command);
生成一个子进程，调用shell执行命令，返回值
1.command为NULL，但shell存在，返回非零值，否则返回0
2.如果无法创建子进程，返回－1值
3.如果执行成功，返回命令执行的返回状态值
4.如果shell不能执行，返回127

====线程====
#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
    void *(*start)(void *), void *arg);
创建一个线程，成功返回0，－1表示出错

#include <pthread.h>
void pthread_exit(void *retval);
结束线程

#include <pthread.h>
pthread_t pthread_self(void);
获取线程自身的ID

#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);
判断是否同一线程，返回非零相同，0表示不同

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
回收线程，返回0表示成功，非零出错

#include <pthread.h>
int pthread_detach(pthread_t thread);
分离线程，返回0成功，非零出错

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
锁住或是解锁，返回0成功，非零出错

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex,
    const pthread_mutexattr_t *attr);
动态初始化一个互斥锁，返回0成功，非零出错

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
销毁动态分配的互斥锁，返回0成功，非零出错

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
发送/广播/等待一个条件变量，返回0成功，非零出错

#include <pthread.h>
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
    const struct timespec *abstime);
等待一个条件变量，超时返回，返回0成功，非零出错

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
动态初始化一个条件变量，返回0成功，非零出错

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
销毁一个条件变量，返回0成功，非零出错

#include <pthread.h>
int pthread_once(pthread_once_t *once_control, void (*init)(void));
保证原子的只执行一次init函数，返回0成功，非零出错

#include <pthread.h>
int pthread_cancel(pthread_t thread);
取消线程，返回0成功，非零失败

#include <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
设置是否响应线程取消信号/设置同步还是异步响应线程取消信号
返回0成功，非零出错

#include <pthread.h>
void pthread_testcancel(void);
测试取消信号，建立线程取消点

#include <pthread.h>
void pthread_cleanup_push(void (*routine)(void*), void *arg);
void pthread_cleanup_pop(int execute);
压入/弹出一个线程清理函数，执行点如下所示：
1.线程被取消
2.线程使用pthread_exit函数退出
3.弹出的时候参数指定非零值

#include <signal.h>
int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset);
设置线程的信号处理，返回0成功，非零出错

#include <signal.h>
int pthread_kill(pthread_t thread, int sig);
发送信号给指定的线程，一般发送0测试线程是否活着，返回
0成功，非零出错

 

 

转载于:https://www.cnblogs.com/y2ghost/p/4362932.html