Linux編程-回憶錄五，linux編程回憶錄

Linux編程-回憶錄五，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成功，非零出錯