#include <fcntl.h>
int open(const char *path, int oflag,.../* mode_t mode */);
int openat(int fd,const char *path, int oflag,.../* mode_t mode*/);
										//成功返回文件描述符，出错返回-1

#include <fcntl.h>
int creat(const char *path, mode_t mode);
									//成功返回只写打开的文件描述符，出错返回-1
//等效于open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
//不怎么用了，用open都可以实现，且更灵活

#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
									//成功返回新的文件偏移量，出错返回-1

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t nbytes);
										//返回实际读到的字节数，出错返回-1

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t nbytes);
											//返回写入字节数，出错返回-1

#include <unistd.h>
int dup(int fd);
int dup2(int fd, ing fd2);
							//成功返回新的文件描述符，出错返回-1

#include <unistd.h>
int close(int fd);		//成功返回0，否则返回-1

#include <unistd.h>
int fsync(int fd);
int fdatasync(int fd);
						//成功返回0，否则返回-1
void sync(void);

#include <fcntl.h>
int fcntl(int fd, int cmd, .../*int arg*/);
								//返回值：成功则依赖于cmd，出错返回-1

#include <sys/ioctl.h>
int ioctl(int fd, int request, ...); //出错返回-1，成功返回其他值

#include <stdio.h>
FILE* fopen(const char * path, const char * mode);
									//成功返回文件指针，否则返回NULL

#include <stdio.h>
FILE* fdopen(int fd, const char * mode);

#include <stdio.h>
int fclose(FILE * stream);
						//成功返回0，失败返回EOF（-1），设置errno

#include <stdio.h>
int fcloseall(void);
				//该函数始终返回0；该函数是linux特有的

#include <stdio.h>
int fgetc(FILE * stream);
	//读取一个字符，并把该无符号字符强转成int返回。文件结尾，错误都返回EOF（-1）

#include <stdio.h>
int ungetc(int c,FILE * stream);
	//把c强转为无符号字符，放回流中，成功返回c，否则返回EOF
	//如果使用了一次定位函数，所有推回的字符被丢弃

#include <stdio.h>
char * fgets(char *str, int size, FILE * stream);
	//从流中读取最多size-1个字节数据，遇到文件尾或换行时读入结束，如果读到‘\n’
	//也放入str，最后把空字符'\0'放到str结尾。成功返回str，失败返回NULL

#include <stdio.h>
size_t fread(void *buf, size_t size, size_t nr, FILE* stream);
	//从流中读取nr个数据，每个数据大小为size，放入buf中
	//实际读入的个数被返回（注意不是字节数）
	//返回小于nr的值时读取失败或文件结束，用ferror()和feof()判断

#include <stdio.h>
//写入单个字符
int fput(int c, FILE * stream);
	//成功返回c,否则返回EOF
//写入字符串
int fputs(const char *str, FILE *stream);
	//将str中'\0'前部分写入stream指向的流中，成功返回非负整数，失败EOF
//写入二进制数据
size_t fwrite(void *buf, size_t size, size_t nr, FILE *stream);
	//把buf指向的nr个元素（每个元素大小为size）写入流，返回实际写入个数，小于nr出错

#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
	//成功返回0，清空文件结束标志，取消ungetc()操作，错误返回-1

//将流位置设置到pos处
int fsetpos(FILE *stream, const fpos_t *pos);
	//成功返回0，否则返回-1
//将当前位置填入pos
int fegtpos(FILE *stream, fpos_t *pos);

void rewind(FILE *stream);
	//等于 fseek(stream,0,SEEK_SET); 位置重置为初始位置

//返回当前流位置
long fetll(FILE *stream);
	//错误返回-1

//清洗一个流，流中数据立即刷新到内核中
int fflush(FILE *stream);

#include <stdio.h>
//测试流上是否设置了错误标志
int ferror(FILE *stream);
	//如果有错误标记，返回非0，否则返回0
//测试文件结尾标记是否被设置
int feof(FILE *stream);
	//如果有文件结束标记，返回非0，否则返回0
//清空错误和结尾标记
void cleareer(FILE *stream);

#include <stdio.h>
void setbuf(FILE *stream, char *buf);
	//buf为NULL是关闭缓冲，否则大小由常量BUFSIZ决定
int setvbuf(FILE *stream, char *buf, int mode, size_t size);
	//必须在流打开后，任何操作之前调用
	//成功返回0，否则返回非0

#include <stdio.h>
int fileno(FILE *stream);
	//成功返回和流关联的文件描述符，否则返回-1

#include <stdio.h>
void flockfile(FILE *stream);
	//等待流解锁 并 获得锁 然后返回
vodi funlockfile(FILE *stream); //解锁

//非阻塞加锁版本
int ftrylockfile(FILE *stream);
	//没有拿到锁返回非零，拿到了返回0

#include <stdio.h>
int getc_unlocked(FILE *stream);
int getchar_unlocked(void);
int putc_unlocked(int c, FILE *stream);
int putchar_unlocked(int c);

void clearerr_unlocked(FILE *stream);
int feof_unlocked(FILE *stream);
int ferror_unlocked(FILE *stream);
int fileno_unlocked(FILE *stream);
int fflush_unlocked(FILE *stream);
int fgetc_unlocked(FILE *stream);
int fputc_unlocked(int c, FILE *stream);
size_t fread_unlocked(void *ptr, size_t size, size_t n,
                      FILE *stream);
size_t fwrite_unlocked(const void *ptr, size_t size, size_t n,
                      FILE *stream);

char *fgets_unlocked(char *s, int n, FILE *stream);
int fputs_unlocked(const char *s, FILE *stream);
...

//1
if(open("path/a.txt",O_RDWR|O_NONBLOCK) == -1 ) return -1;
//2
int flags;
if((flags = fcntl(fd, F_GETFL, NULL)) < 0) return -1;
if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) return -1;

#include <fcntl.h>
int fcntl(int fd, int cmd, ... /*struct flock * flockptr*/);
struct flock {
    short l_type;	/*F_RDLCK，F_WRLCK，or F_UNLCK*/
    short l_whence;	/*SEEK_SET,SEEK_CUR or SEEK_END*/
    off_t l_start; 	/*offset in bytes,relative to l_whence*/
    off_t l_len;	/*length,in bytes, 0 mens lock to EOF*/
    pid_t l_pid;	/*returned with F_GETLK*/
}

#include <sys/select.h>
int select(int maxfdp1, fd_set * readfds,
          fd_set * writefds, fd_set * exceptfds,
          struct timeval *restrict tvptr);
				//返回准备就绪的描述符数量；若超时返回0，出错返回-1

#include <sys/select.h>
int pselect(int maxfdp1, fd_set * readfds,
          fd_set * writefds, fd_set * exceptfds,
          const struct timespec *restrict tsptr,
          const sigset_t * sigmask);
				//返回准备就绪的描述符数量；若超时返回0，出错返回-1

#include <poll.h>
int poll(struct pollfd fdarray[], nfds_t nfds, int timeout);
							//返回就绪的描述符数目，若超时返回0，出错返回-1

//与select不同，poll不是为每个条件构造一个描述符集，而是构造一个pollfd结构的数组
struct pollfd {
    int fd;			/*file descriptor to check, or < 0 to ignore*/
    short events;	/*events of interest on fd*/
    short revents;	/*events that occured on fd 由内核设置，告诉我们发生了什么*/
}

#include <sys/epoll.h>
int epoll_create(int size);
					//创建一个实例，返回一个epoll fd，出错返回-1
int epoll_create1(int flag); // EPOLL_CLOEXEC设置描述符标志  为0和epoll_create一样

int epfd;
epfd = epoll_create(100);/*plan to watch ~100 fds*/
if(epfd<0){
    perror("epoll_create");
}

#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
						//成功返回0，失败返回-1
struct epoll_event {
	__u32 events; /* events */
	union {
		void *ptr;
		int fd;
		__u32 u32;
		__u64 u64;
	} data;
};

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
							//返回事件数，出错返回-1

#define MAX_EVENTS 64
struct epoll_event * events;
int nr_events, i, epfd;
events = malloc(sizeof(struct epoll_event) * MAX_EVENTS); /*创建接收结果的数组*/
if(!events){
    perror("malloc");
    return 1;
}
nr_events = epoll_wait(epfd, events, MAX_EVENTS, -1);
if(nr_events < 0){
    perror("epoll_wait");
    free(events);
    return 1;
}
for(i=0; i < nr_events; ++i){
    printf("event=%ld on fd=%d\n",events[i].events,events[i].data.fd);
    /*do something IO*/
}
free(events);

int main(int argc, char *argv[]);

#include <stdlib.h>
void exit(int status);
void _Exit(int status);
#include <unistd.h>
void _exit(int status);

#include <stdlib.h>
int atexit(void (*func)(void));
					//成返回0，失败返回非0

extern char **environ;

#include <stdlib.h>
char *getenv(const char *name);
				//返回与name关联的value指针，找不到返回NULL
int putenv(char *str);
				//成功返回0，出错非0
int setenv(const char *name, const char *value, int rewrite);
int unsetenv(const char *name);
				//成功返回0，失败返回-1

#include <unistd.h>
pid_t getpid(void);		//返回进程ID
pid_t getppid(void);	//返回父进程ID

uid_t getuid(void);		//返回调用程序的实际用户ID
uid_t geteudi(void);	//返回有效用户ID

gid_t getgid(void);		//返回实际组ID
gid_t getegid(void);	//返回有效组ID

#include <unistd.h>
pid_t fork(void);
			//子进程返回0，父进程返回子进程ID，出错返回-1

#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);
								//俩函数成功返回进程id，出错返回0或-1

pid == -1;  /*等待任一子进程，和wait没区别*/
pid > 0;	/*等待进程id与pid相等的子进程*/
pid == 0;	/*等待组id等于调用进程组id的任一子程序*/
pid < -1;	/*等待组id等于pid绝对值的任一子程序*/

WCONTINUED /*若实现支持作业控制，那么由pid指定的任一子进程在停止后已经继续，但其状态尚未报告，则返回其状态*/
WNOHANG 	/*若没有等待的子进程，waitpid不阻塞 此时返回值为0*/
WUNTRACED	/*若实现支持作业控制，那么由pid指定的任一子进程停止，但其状态紫停止以来尚未报告，则返回其状态*/

#include <unistd.h>
int execl(const char *pathname, const char * arg0, ... /* (char *)0 */);
int execv(const char *pathname, char *const argv[]);
int execle(const char *pathname, const char *arg0, ... 
           /* (char *)0 , char *const envp[] */);
int execve(const char *pathname, char *const argv[], char *const envp[])

int execlp(const char *filename, const char *arg0, ... /* (char *)0 */);
int execvp(const char *filename, char *const argv[]);

int fexecve(int fd, char *const argv[], char *const envp[]);
									//7个函数失败返回-1，若成功不返回

execl(“/bin/ls”,”ls”,”-l”,NULL); //ls -l  第一个参数描述命令path 
char* av[]={"ls","-l",NULL};
execv("/bin/ls",av); //ls -l

execlp(“ls”,”ls”,”-l”,NULL);
char* argin[]={"ls", "-l", NULL};
execvp(argin[0],argin); // ls -l;
//execlp 和 execvp 的区别是不用完整path，会在系统path环境变量中搜索

#include <sys/times.h>
clock_t times(struct tms *buf);
				//成功返回流逝的墙上的时间，出错返回-1
				//1970 年 1 月 1 日 00:00:00 到当前时间的秒数  64bit

struct tms {
    clock_t tms_utime;	/* user CPU time */
    clock_t tms_stime;	/* system CPU time */
    clock_t tms_cutime;	/* user CPU time,terminated children */
    clock_t tms_cstime;	/* system cpu time, terminated children */
};

1) SIGHUP: #当用户退出shell时，由该shell启动的所有进程将收到这个信号，默认动作为终止进程
2）SIGINT：#当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止里程。
3）SIGQUIT：#当用户按下<ctrl+\>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。默认动作为终止进程。
4）SIGILL：#CPU检测到某进程执行了非法指令。默认动作为终止进程并产生core文件
5）SIGTRAP：#该信号由断点指令或其他trap指令产生。默认动作为终止里程并产生core文件。
6 ) SIGABRT:#调用abort函数时产生该信号。默认动作为终止进程并产生core文件。
7）SIGBUS：#非法访问内存地址，包括内存对齐出错，默认动作为终止进程并产生core文件。
8）SIGFPE：#在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为0等所有的算法错误。默认动作为终止进程并产生core文件。
9）SIGKILL：#无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法。
10）SIGUSE1：#用户定义的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程。
11）SIGSEGV：#指示进程进行了无效内存访问。默认动作为终止进程并产生core文件。
12）SIGUSR2：#这是另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。1
13）SIGPIPE：#Broken pipe向一个没有读端的管道写数据。默认动作为终止进程。
14) SIGALRM:#定时器超时，超时的时间由系统调用alarm设置。默认动作为终止进程。
15）SIGTERM：#程序结束信号，与SIGKILL不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。执行shell命令Kill时，缺省产生这个信号。默认动作为终止进程。
16）SIGCHLD：#子进程结束时，父进程会收到这个信号。默认动作为忽略这个信号。
17）SIGCONT：#停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为终止进程。
18）SIGTTIN：#后台进程读终端控制台。默认动作为暂停进程。
19）SIGTSTP：#停止进程的运行。按下<ctrl+z>组合键时发出这个信号。默认动作为暂停进程。
21）SIGTTOU:#该信号类似于SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程。
22）SIGURG：#套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号。
23）SIGXFSZ：#进程执行时间超过了分配给该进程的CPU时间，系统产生该信号并发送给该进程。默认动作为终止进程。
24）SIGXFSZ：#超过文件的最大长度设置。默认动作为终止进程。
25）SIGVTALRM：#虚拟时钟超时时产生该信号。类似于SIGALRM，但是该信号只计算该进程占用CPU的使用时间。默认动作为终止进程。
26）SGIPROF：#类似于SIGVTALRM，它不公包括该进程占用CPU时间还包括执行系统调用时间。默认动作为终止进程。
27）SIGWINCH：#窗口变化大小时发出。默认动作为忽略该信号。
28）SIGIO：#此信号向进程指示发出了一个异步IO事件。默认动作为忽略。
29）SIGPWR：#关机。默认动作为终止进程。
30）SIGSYS：#无效的系统调用。默认动作为终止进程并产生core文件。
31）SIGRTMIN～（64）SIGRTMAX：#LINUX的实时信号，它们没有固定的含义（可以由用户自定义）。所有的实时信号的默认动作都为终止进程

#include <signal.h>
void (*signal(int signo, void (*func)(int)))(int);
					//成功返回以前的信号配置，出错返回SIG_ERR
//有的实现分开定义，但意思一样
typedef void Sigfunc(int);
Sigfunc *signal(int, Sigfunc *);

#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
void handle_sig_child()
{
	int status;
	pid_t pid;
	while(1){
		pid = waitpid(-1, &status, WUNTRACED | WCONTINUED | WNOHANG);
        if(pid <= 0) break;
		printf("recv child pid %d \n", pid);
		if(WIFEXITED(status))
			printf("child process exited with %d\n", WEXITSTATUS(status));
		else if(WIFSIGNALED(status))
			printf("child process signaled with %d\n", WTERMSIG(status));
		else if(WIFSTOPPED(status))
			printf("child process stoped\n");
		else if(WIFCONTINUED(status))
			printf("child process continued\n");
	}
}

#include <signal.h>
int kill(pid_t pid, int signo);
int raise(int signo);
				//成功返回0 失败返回-1  raise(signo)等价于kill(getpid(),signo)

pid > 0 	/*将信号发送给进程*/
pid == 0	/*将信号发送给同一进程组的所有进程*/ 
pid < 0		/*发送给其他进程组，id为pid绝对值*/
pid == -1 	/*发送给所有进程（前提有权限）*/

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
					//返回值 0或以前设置的闹钟余留秒数

#include <unistd.h>
int pause(void);
			//返回-1，errno设置为EINTR，只有执行了一个信号处理程序并从其返回，pause才返回

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
						//4个函数成功返回0，出错返回-1
int sigismember(const sigset_t *set, int signo);
						//若真，返回1，假返回0

#include <signal.h>
int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
											//成功返回0，出错返回-1

SIG_BLOCK 	#新屏蔽字取set和老屏蔽字的并集
SIG_UNBLOCK	#新屏蔽字取set和老屏蔽字的交集
SIG_SETMASK	#新屏蔽字取set

#include <signal.h>
int sigpending(sigset_t *set);
				//成功返回0，出错返回-1

#include <signal.h>
int sigaction(int signo, const struct sigaction *restrict act,
             struct sigaction *restrict oact);
					//成功返回0，失败返回-1

struct sigaction
{
	void (*sa_handler)(int);
	void (*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t sa_mask;
	int sa_flags;
};
/*
sa_handler : 早期的捕捉函数

sa_sigaction : 新添加的捕捉函数，可以传参, 和sa_handler互斥，两者通过sa_flags选择采用哪种捕捉函数

sa_mask : 在执行捕捉函数时，设置阻塞其它信号，sa_mask | 进程阻塞信号集，退出捕捉函数后，还原回原有的
阻塞信号集

sa_flags : SA_SIGINFO 或者 0 用来指定调用sa_handler还是sa_sigaction ,SA_SIGINFO 时为调用sa_sigaction，
SA_RESTART 让被打断的系统调用重新开始
*/
//如果设置了SA_SIGINFO,则按下列方式调用信号处理程序
void handler(int signo, siginfo_t *info, void *context);



//一个栗子
struct sigaction act;
act.sa_handler = sig_handle;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGQUIT); //当进入信号处理函数的时候，屏蔽掉SIGQUIT的递达
sigaction(SIGINT, &act, NULL);

extern char *sys_siglist[];

#include <signal.h>
void psignal(int signo, const char *msg); //到标准错误

#include <string.h>
char *strsignal(int signo);		//返回字符串指针

#include <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);
						//比较tid，相等返回非0，否则返回0
pthread_t pthread_self(void);
						//返回调用线程的tid

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp,
                  const pthread_attr_t *restrict attr,
                  void *(*start_rtn)(void *),
                  void *restrict arg);
//若成功返回0，否则返回错误编号

#include <pthread.h>
void pthread_exit(void *rval_ptr)

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
						//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_cancel(pthread_t tid);
				//成功返回0，否则返回错误码

#include <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *), void *arg);
void pthread_cleanup_pop(int execute);

#include <pthread.h>
int pthread_detach(pthread_t tid);
					//成功返回0，失败返回错误编号

#include <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destory(pthread_attr_t *attr);
						//成功返回0，失败返回错误编号

detachstate #线程分离状态属性
guardsize	#线程栈末尾的警戒缓冲区大小
stackaddr	#线程栈的最低地址
stacksize	#线程栈的最小长度

#include <pthread.h>
int pthread_attr_getdetachstate(const pthread_attr_t *restrict attr,
                               int *detachstate);
int pthread_attr_setdetachstate(pthread_attr_t *attr, int *detachstate);
										//成功返回0，失败返回错误编号

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restirct mutex,
                      const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
								//成功返回0，否则返回错误编号

#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);
								//成功返回0，否则返回错误编号

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,
                           const struct timespec *restrict tsptr);
								//成功返回0，否则返回错误编号	

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                       const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
								//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
								//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
								//成功返回0，否则返回错误编号

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,
                              const struct timespec *restrict tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,
                              const struct timespec *restrict tsptr);
								//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond,
                     const pthread_condattr_t *restrict attr);
int phtread_cond_destroy(pthread_cond_t *cond);
								//成功返回0，否则返回错误编号

#include <pthread.h>
#include <time.h>
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 tsptr);
										//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond); 
int pthread_cond_broadcast(pthread_cond_t *cond);
										//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);
										//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
										//成功返回0，否则返回错误编号

#include<pthread.h>
int pthread_barrier_init(pthread_barrier_t *restrict barrier,
                         const pthread_barrierattr_ty *restrict attr,
                         unsigned int count); 
int pthread_barrier_destroy(pthread_barrier_t *barrier);
										//成功返回0，否则返回错误编号

#include <pthread.h>
int pthread_barrier_wait(pthread_barrier_t *barrier);
						//成功返回0或PTHREAD_BARRIER_SERIAL_THREAD，失败返回错误编码

pthread_once_t once_control = PTHREAD_ONCE_INIT;

int pthread_once(pthread_once_t *once_control,void(*init_routine)(void));

#include <sys/socket.h>
int socket(int domain, int type, int protocol);
							//成功返回文件（套接字）描述符，出错返回-1

AF_INET		# IPv4因特网域
AF_INET6	# IPv6因特网域
AF_UNIX		# UNIX域
AF_UPSPEC	# 未指定

SOCK_DGRAM		# 固定长度的，无连接的，不可靠的报文传递
SOCK_STREAM		# 有序的，可靠地，双向的，面向连接的字节流
SOCK_RAW		# IP协议的数据报接口（在POSIX.1中为可选）
SOCK_SEQPACKET	# 固定长度的，有序的，可靠的，面向连接的报文传递

IPPROTO_IP		# IPv4网际协议
IPPROTO_IPV6	# IPv6网际协议（在POSIX.1中为可选）	
IPPROTO_ICMP	# 因特网控制报文协议
IPPROTO_RAW		# 原始ip数据包协议（在POSIX.1中为可选）
IPPROTO_TCP		# 传输控制协议
IPPROTO_UDP		# 用户数据报协议

#include <sys/socket.h>
int shutdown(int sockfd, int how);	
					//成功返回0，出错返回-1

SHUT_RD		# 关闭读端
SHUT_WR		# 关闭写端
SHUT_RDWR	# 同时关闭读端写端

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);