新手园地& & & 硬件问题Linux系统管理Linux网络问题Linux环境编程Linux桌面系统国产LinuxBSD& & & BSD文档中心AIX& & & 新手入门& & & AIX文档中心& & & 资源下载& & & Power高级应用& & & IBM存储AS400Solaris& & & Solaris文档中心HP-UX& & & HP文档中心SCO UNIX& & & SCO文档中心互操作专区IRIXTru64 UNIXMac OS X门户网站运维集群和高可用服务器应用监控和防护虚拟化技术架构设计行业应用和管理服务器及硬件技术& & & 服务器资源下载云计算& & & 云计算文档中心& & & 云计算业界& & & 云计算资源下载存储备份& & & 存储文档中心& & & 存储业界& & & 存储资源下载& & & Symantec技术交流区安全技术网络技术& & & 网络技术文档中心C/C++& & & GUI编程& & & Functional编程内核源码& & & 内核问题移动开发& & & 移动开发技术资料ShellPerlJava& & & Java文档中心PHP& & & php文档中心Python& & & Python文档中心RubyCPU与编译器嵌入式开发驱动开发Web开发VoIP开发技术MySQL& & & MySQL文档中心SybaseOraclePostgreSQLDB2Informix数据仓库与数据挖掘NoSQL技术IT业界新闻与评论IT职业生涯& & & 猎头招聘IT图书与评论& & & CU技术图书大系& & & Linux书友会二手交易下载共享Linux文档专区IT培训与认证& & & 培训交流& & & 认证培训清茶斋投资理财运动地带快乐数码摄影& & & 摄影器材& & & 摄影比赛专区IT爱车族旅游天下站务交流版主会议室博客SNS站务交流区CU活动专区& & & Power活动专区& & & 拍卖交流区频道交流区
白手起家, 积分 15, 距离下一级还需 185 积分
论坛徽章:0
请问下，如果我在用户层使用posix定时器，这个定时器接口的精度是微妙级别的，
但Linux系统内核的tick一般都是毫秒级别的，这意味这调度是毫秒级别的，那么
理论上用户空间的定时器是达不到微妙级别的吧，请问我的理解对吗？如果想在
用户空间达到微妙级别的精度有什么办法呢？
&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp&&nbsp|&&nbsp
大富大贵, 积分 18012, 距离下一级还需 1988 积分
论坛徽章:15
也不绝对，关键看系统里有哪些clocksource。
比如HPET，
白手起家, 积分 15, 距离下一级还需 185 积分
论坛徽章:0
我的意识是就算底层的时钟源再精准（比如HEPT），但时钟中断后需要通知进程处理，但进程的调度是tick（毫秒）级别的，受限于tick调度，这样不管底层的时钟源再精准，
进程的timer都达不到微妙级别。
腰缠万贯, 积分 9924, 距离下一级还需 76 积分
论坛徽章:5
本帖最后由 _nosay 于
21:57 编辑
ppcc800330
哦，是说用户态实现的定时器呀。
稍有积蓄, 积分 256, 距离下一级还需 244 积分
论坛徽章:2
usleep和msleep，我记得都是通过内核的 nanosleep 来实现的。
最精确的：直接去读cpu的counter寄存器，跟cpu的时钟频率做换算。
大富大贵, 积分 18012, 距离下一级还需 1988 积分
论坛徽章:15
本帖最后由 nswcfd 于
11:02 编辑
仅供参考。
两台机器上man nanosleep的区别。
版本1，Linux 2.6.9 @ ，注意BUGS部分。
NAME
& && & nanosleep - pause execution for a specified time
& && & #define _POSIX_C_SOURCE 199309 #include &time.h&
& && & int nanosleep(const struct timespec *req, struct timespec *rem);
& && & The current implementation of nanosleep() is based on the normal kernel timer mechanism, which has a resolution of 1/HZ s (see time(7)).&&Therefore, nanosleep() pauses always for&&at
& && & least&&the specified time, however it can take up to 10 ms longer than specified until the process becomes runnable again. For the same reason, the value returned in case of a deliv-
& && & ered signal in *rem is usually rounded to the next larger multiple of 1/HZ s.
& &Old behaviour
& && & In order to support applications requiring much more precise pauses (e.g., in order to control some time-critical hardware), nanosleep() would handle pauses of up&&to&&2 ms&&by&&busy
& && & waiting&&with&&microsecond&&precision when called from a process scheduled under a real-time policy like SCHED_FIFO or SCHED_RR.&&This special extension was removed in kernel 2.5.39,
& && & hence is still present in current 2.4 kernels, but not in 2.6 kernels.
& && & In Linux 2.4, if nanosleep() is stopped by a signal (e.g., SIGTSTP), then the call fails with the error EINTR after the process is resumed by a SIGCONT signal.&&If the system call is
& && & subsequently restarted, then the time that the process spent in the stopped state is not counted against the sleep interval.
CONFORMING TO
& && & POSIX.1-2001.
& && & sched_setscheduler(2), timer_create(2), sleep(3), usleep(3)
Linux 2.6.9& && && && && && && &&&& && && && && && && & NANOSLEEP(2)
版本2，，3.22，没有前面的BUG描述（受限于timer精度）。
NAME
& && & nanosleep - high-resolution sleep
& && & #include &time.h&
& && & int nanosleep(const struct timespec *req, struct timespec *rem);
& &Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
& && & nanosleep(): _POSIX_C_SOURCE &= 199309L
CONFORMING TO
& && & POSIX.1-2001.
& && & If the interval specified in req is not an exact multiple of the granularity underlying clock (see time(7)), then the interval will be rounded up to the next multiple.&&Furthermore, after&&the&&sleep&&com-
& && & pletes, there may still be a delay before the CPU becomes free to once again execute the calling thread.
& && & The&&fact that nanosleep() sleeps for a relative interval can be problematic if the call is repeatedly restarted after being interrupted by signals, since the time between the interruptions and restarts of
& && & the call will lead to drift in the time when the sleep finally completes.&&This problem can be avoided by using clock_nanosleep(2) with an absolute time value.
& && & POSIX.1 specifies that nanosleep() should measure time against the CLOCK_REALTIME clock.&&However, Linux measures the time using the CLOCK_MONOTONIC clock.&&This probably does not matter, since the POSIX.1
& && & specification for clock_settime() says that discontinuous changes in CLOCK_REALTIME should not affect nanosleep():
& && && && &&&Setting&&the&&value&&of&&the&&CLOCK_REALTIME&&clock&&via&&clock_settime()&&shall&&have&&no effect on threads that are blocked waiting for a relative time service based upon this clock, including the
& && && && &&&nanosleep() ...&&Consequently, these time services shall expire when the requested relative interval elapses, independently of the new or old value of the clock.
& &Old behavior
& && & In order to support applications requiring much more precise pauses (e.g., in order to control some time-critical hardware), nanosleep() would handle pauses of up to 2 ms by busy waiting&&with&&microsecond
& && & precision&&when called from a thread scheduled under a real-time policy like SCHED_FIFO or SCHED_RR.&&This special extension was removed in kernel 2.5.39, hence is still present in current 2.4 kernels, but
& && & not in 2.6 kernels.
& && & In Linux 2.4, if nanosleep() is stopped by a signal (e.g., SIGTSTP), then the call fails with the error EINTR after the thread is resumed by a SIGCONT signal.&&If the system call is subsequently restarted,
& && & then the time that the thread spent in the stopped state is not counted against the sleep interval.
& && & clock_nanosleep(2), sched_setscheduler(2), sleep(3), timer_create(2), usleep(3), time(7)
& && & This page is part of release 3.22 of the Linux man-pages project.&&A description of the project, and information about reporting bugs, can be found at
Linux& && && && && && && && && &&&& && && && && && && & NANOSLEEP(2)
大富大贵, 积分 18012, 距离下一级还需 1988 积分
论坛徽章:15
PS，参考２，
白手起家, 积分 54, 距离下一级还需 146 积分
论坛徽章:1
用户是可以达到ns级的定时器精度的。而且你说的定时器受限于ms级的tick精度也是不对的。内核开了高精度定时器时，tick的精度和定时器的精度完全没有关系。
北京皓辰网域网络信息技术有限公司. 版权所有 京ICP证:060528号 北京市公安局海淀分局网监中心备案编号：
广播电视节目制作经营许可证(京) 字第1234号
中国互联网协会会员&&联系我们：
感谢所有关心和支持过ChinaUnix的朋友们
转载本站内容请注明原作者名及出处POSIX定时器:timer
我的图书馆
POSIX定时器:timer
POSIX创建、初始化以及删除一个定时器的行动被分为三个不同的函数：timer_create()(创建定时器)、timer_settime()(初始化定时器)以及timer_delete(销毁它)
一个典型的例子如：
#include &sys/time.h&
timer_t fade_in_
int myclass::starttimer()
&&& memset(&evp, 0, sizeof(evp));
&&& evp.sigev_value.sival_ptr =&//这里传一个参数进去，在timer的callback回调函数里面可以获得它&&
&&& evp.sigev_notify = SIGEV_THREAD;&//定时器到期后内核创建一个线程执行sigev_notify_function函数&
&&& evp.sigev_notify_function = fade_in_ //这个就是指定回调函数
&&& int ret = 0;
&&& ret = timer_create(CLOCK_REALTIME, &evp, &fade_in_timer);
&&& if(ret & 0)
&&&&&&& printf("timer_create() fail, ret:%d", ret);
&&& ts.it_interval.tv_sec = 0;
&&& ts.it_interval.tv_nsec = ; //200ms&
&&& ts.it_value.tv_sec = 0;
&&& ts.it_value.tv_nsec = ; //200ms&
&&& ret = timer_settime(fade_in_timer, TIMER_ABSTIME, &ts, NULL);
&&& if(ret & 0)
&&&&&&& printf("timer_settime() fail, ret:%d", ret);&
&&&&&&& timer_delete(fade_in_timer);
&&&&&&& timer_created =
&&& return 0;
/*static*/void myclass::fade_in_callback(union sigval v)
&&& //v.sival_ptr 就是创建timer时传进来的指针，最后在合适的地方删除一下timer
&&& myclass *ptr = (myclass*)v.sival_
&&& timer_delete(audiotrack-&fade_in_timer);
使用timer时注意两点：
1.回调函数如果不是C函数而是类的成员函数，则不能用普通成员函数，必须用静态成员函数，因为普通成员函数含有隐含参数--this指针
2.timer定时的时间间隔，第一次是ts.it_value这么长，后面每次时间间隔是ts.it_interval这么长
&&& ts.it_interval.tv_sec = 0;
&&& ts.it_interval.tv_nsec = ; //200ms&
&&& ts.it_value.tv_sec = 0;
&&& ts.it_value.tv_nsec = ; //200ms&
版权声明：本文为博主原创文章，未经博主允许不得转载。
发表评论：
TA的最新馆藏本帖子已过去太久远了，不再提供回复功能。[linux定时器]Linux下的高精度时间获得与定时器
· · · ·
您当前的位置： → [linux定时器]Linux下的高精度时间获得与定时器
[linux定时器]Linux下的高精度时间获得与定时器
篇一 : Linux下的高精度时间获得与定时器本文主要介绍Linux下高精度时间函数，及相关的具有超时机制的函数，对定时器也进行简单的介绍。在linux下通常可用的精度最高的时间接口是gettimeofday，它返回一个timeval结构，其精度为us，即10-6 秒，大多数情况这个精度已经够用了。不过有时为了更高的精度，比如纳秒级的时间精度，我们需求探索Linux为我们提供的时间调用。首先介绍struct timespec结构，这个结构体有两个成员，一个是秒，一个是纳秒。在librt库中，提供了高精度的时间函数，分别是：long clock_gettime(clockid_t ,struct timespec*)获取特定时钟的时间，时间通过fp结构传回，目前定义了6种时钟，分别是CLOCK_REALTIME 系统当前时间，从日算起 CLOCK_MONOTONIC 系统的启动时间，不能被设置 CLOCK_PROCESS_CPUTIME_ID 进程运行时间 CLOCK_THREAD_CPUTIME_ID 线程运行时间 CLOCK_REALTIME_HR CLOCK_REALTIME的高精度版本 CLOCK_MONOTONIC_HR CLOCK_MONOTONIC的高精度版本获取特定时钟的时间精度：long clock_getres(clockid_t )设置特定时钟的时间：long clock_settime(clockid_t ,struct timespec*)休眠time中指定的时间，如果遇到信号中断而提前返回，则由left_time返回剩余的时间：long clock_nanosleep(clockid_t ,int flag,timespec* time,timespec* left_time)有了这些个时间函数之后，我们再来看下如何实现一些不同精度的简单的定时器。最粗糙的定时器可以由sleep来实现，其精度为秒级，系统也提供像nanosleep，usleep，ualarm等，当然你愿意也可以由poll(ms)、select(us)、ppoll或pslect(ns)等来实现各种精度的sleep。通过这些高精度的sleep函数，也可以实现一系统不同精度的定时器。通过上述sleep实现的定时器通常需要我们自行进行编码，而且过多的sleep也会导致某个cpu不能充分的利用，对于大量定时器的场合就需要小心编写代码，这种方式通常以单独线程控制或主循环轮询的方式查看哪些定时器到期。总体来说，实现复杂，效率较低，而且也没有一种好的定时器到期时的通知机制，通常是被动由定时器线程强行执行或者自身线程在线程主循环中检查到期的定时器并执行。下面我们将探索一下由操作系统提供的一些定时器机制。操作系统提供了两个种类的定时器，一种是显式的定时器，另一种是隐藏在调用的超时时间或特定文件属性之上。后者我们在前面已经见到过，比如select、套接字描述符的超时属性，这些需要在不同的编程领域去积累，当然它们也有各自的精度。下面我们主要介绍一下系统提供的显式的定时器。Linux系统为每个进程提供了三个间隔定时器，精度为us。定时器到期时将触发相应的信号，定时器可能会重新开始，值得注意的是，fork生成的子进程并不继承父进程的定时器。int getitimer(int type, itimerval* val) int setitimer(int type, itimerval* nval, itimerval* oval)itimerval 有两个成员，it_interval和it_value，均为timeval类型，前者保存的是下次定时器的定时间隔，后者为本次超时时的定时间隔。也就是说，定时器将从it_value减少，当变为0时，发送信号，并从it_interval取值，重新开始定时器。如果val被置为0，则停止定时器。getitimer()用于设置一个定时器，而setitimer用于修改已经设置的定时器，如果在设置时定时器尚未超时，则剩余时间保存于oval。定时器定时器三个定时器分别是：ITIMER_REAL 以系统时间递减，超时时投递SIGALRM信号 ITIMER_VIRTUAL 以进程执行时间递减，超时时投递SIGVTALRM ITIMER_PROF 当进程执行或进程执行系统调用时均递减，超时时投递SIGPROF信号。此外Posix1.b中为我们提供了实时高精度的定时工具，精度可以达到纳秒。不过每个进程只能有一个。int timer_creat() int timer_delete() int timer_gettime() int timer_settime()具体使用方法不在这里详述，可见系统提供的定时器是一种珍惜资源，通常只是一种最基本的设施，应用需要使用这个最基本的设施定义多样化的定时器，以满足程序中使用多种及多个定时器。当然系统提供的定时器需要人工设置信号处理等相关工作，需要专门处理信号的代码，这个在一定程度上增加了程序的复杂性。因此说来，从sleep族的定时器到系统显式的定时器，各有优缺点，使用时根据情况权衡选择。篇二 : linux定时器用法用法：#include &sys/time.h&int getitimer(int which, struct itimerval *value);int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);功能描述：获取或设定间歇计时器的值。系统为进程提供三种类型的计时器，每一类以不同的时间域递减其值。当计时器超时，信号被发送到进程，之后计时器重启动。参数：which：间歇计时器类型，有三种选择ITIMER_REAL //数值为0，以系统真实的时间来计算，发送的信号是SIGALRM。ITIMER_VIRTUAL //数值为1，以该进程在用户态下花费的时间来计算，发送的信号是SIGVTALRM。ITIMER_PROF //数值为2， 以该进程在用户态下和内核态下所费的时间来计算，发送的信号是SIGPROF。value，ovalue：时间参数，原型如下struct itimerval {struct timeval it_struct timeval it_};struct timeval {long tv_long tv_};itimerval结构中的it_value是减少的时间,当这个值为0的时候就发出相应的信号了. 然后再将it_value设置为it_interval值. 也就是先处理it_value中设置的值，为0后发送信号(根据which来判断发送什么信号),之后都是根据it_interval的值发送信号。若 it_value为0，就没有相应的信号产生了。getitimer()用计时器的当前值填写value指向的结构体。setitimer()将 value 指向的结构体设为计时器的当前值，如果ovalue不是NULL，将返回计时器原有值。返回说明：成功执行时，返回0。失败返回-1，errno被设为以下的某个值EFAULT：value 或ovalue是不有效的指针EINVAL：其值不是ITIMER_REAL，ITIMER_VIRTUAL 或 ITIMER_PROF之一例子：void sigroutine(int signo){static int count1=0,count2=0;switch (signo){case SIGALRM:count1++;printf("Catch a signal -- SIGALRM \n");
printf("count1 = %d\n\n", count1);signal(SIGALRM, sigroutine);case SIGVTALRM:count2++;printf("Catch a signal -- SIGVTALRM \n");
printf("count2 = %d\n\n", count2);signal(SIGVTALRM, sigroutine);}}int main(){struct itimerval value, ovalue, value2;printf("process id is %d\n", getpid());signal(SIGALRM, sigroutine);signal(SIGVTALRM, sigroutine);value.it_value.tv_sec = 2;value.it_value.tv_usec = 0;value.it_interval.tv_sec = 3;value.it_interval.tv_usec = 0;setitimer(ITIMER_REAL, &value, &ovalue);value2.it_value.tv_sec = 1;value2.it_value.tv_usec = 0;value2.it_interval.tv_sec = 3;value2.it_interval.tv_usec = 0;setitimer(ITIMER_VIRTUAL, &value2, &ovalue);while(1);}
上一篇文章：
下一篇文章：
本文标题：[linux定时器]Linux下的高精度时间获得与定时器&版权说明
文章标题： 文章地址：
1、《[linux定时器]Linux下的高精度时间获得与定时器》一文由262阅读网（）网友提供，版权归原作者本人所有，转载请注明出处！
2、转载或引用本网内容必须是以新闻性或资料性公共免费信息为使用目的的合理、善意引用，不得对本网内容原意进行曲解、修改，同时必须保留本网注明的"稿件来源"，并自负版权等法律责任。
3、对于不当转载或引用本网内容而引起的民事纷争、行政处理或其他损失，本网不承担责任。linux模块（52）
POSIX，全称为可移植性操作系统接口，是一种关于信息技术的IEEE标准。它包括了系统应用程序接口（简称API），以及实时扩展[C语言]。
该标准的目的是定义了标准的基于UNIX操作系统的系统接口和环境来支持源代码级的可移植性。现在，标准主要提供了依赖C语言的一系列标准服务，再将来的版本中，标准将致力于提供基于不同语言的规范。
该标准对核心需求部分定义了一系列任何编程语言都通用的服务，这一部分服务主要从其功能需求方面阐述，而非定义依赖于编程语言的接口。语言规范主要有两部分组成。一部分包括了访问核心服务的编程语言的标准接口，这些核心服务为标准中基于编程语言的核心需求部分所定义；另一部分包含了一个特殊语言服务的标准接口。基于任何语言，与该标准一致的执行都必须遵循语言规范的任何章节。
该标准一共被分为四个部分：
（1）陈述的范围和一系列标准参考（第一章）；
（2）定义和总概念；（第二章）
（3）各种接口设备；（第三章到第九章，第十一章到第十五章）
（4）数据交换格式；（第十章）
该标准的主要目的有：
（1）面向应用
（2）定义接口，而不是它的具体实现；
（3） 涉及资源和可移植性，而非对象；
（4） 基于c语言；
（5）无超级用户，无系统管理；
（6） 最小限度的接口，最小限度的定义；
（7）应用领域广泛；
（8）对以前的实现进行最小限度改变；
（9）对原有程序代码做最小的修改；
（10） 实时扩展；
以下就对各个章节做简要分析。
第一章概述
定义范围的关键要素有：
（1）定义足够的一套功能适用于实时应用程序领域的重要部分；
（2）定义足够的实现规范和性能相关的函数，以便允许实时应用程序完成系统的确定性的响应；
1．2一致性
系统须支持标准中定义的接口，系统能够提供标准中没有要求到的函数和工具。在遵循于该标准的实现中，一种一致性文档是需要用到的，它必须具有与该标准相同的结构，包含有全名，数字，和标准所指示的日期，以及头文件&limits.h&和&unistd.h&中的界限值等等。该一致性文档详细说明了标准中定义的执行行为。该标准要求了应用程序的一致性，所有遵循标准的应用程序都使用基于c语言的服务。
第二章术语和基本需求
该标准中定义了一系列术语，如一致性文档，被定义的实现，可能性，无用的特性等，还定义了一些通用名词，如绝对路径，存取模式，地址空间，适当权限，定时器，异步I/O操作，后台进程，后台进程组，块文件，阻塞进程，等等。
（2）基本概念
扩展安全控制；文件存取允许；文件级别；文件名可移植性；路径名的决定；
（3）错误号
大部分函数都在外部变量errno中提供了错误号，定义如下：
(4)简单系统的数据类型
这些数据类型在头文件&sys/types.h&中定义，它包含了至少以下类型：
用于设备号；
用于进程标志符；
用于文件序列号；
inode_t:用于一些文件参数；
用于连接内容；
用于文件大小；
用于进程或进程组标志符；
在c标准（2）中定义；
用于返回字节数和错误标志的函数；
用于用户标志符；
（4）环境描述
当一个进程开始执行时，将调用一个表示环境的字符串数组，这个数组为外部变量environ所指向，其定义如下：
externchar **
在该章中，标准还总体介绍了c语言定义的一些标志符，数字方面的限制，以及一些符号常量，这些在以后的章节中都会一一出现。
以下是OSE服务的简要设计描述的一个清单。这些要求详细叙述在POSIX规范书中。
进程源语所涉及的函数完成了大多数简单的操作系统服务，如进程处理，进程信号，以及定时器。一般情况下，该标准所确定的进程的所有属性都不能被一个进程源语改变，除非描述符特别指明。
目录与文件
目录与文件所涉及的函数执行了一系列操作系统服务，例如文件的创建和删除，检测，修改特性。它们提供了主要的方法，进程因为一系列I/O操作使用他们来存取文件和目录。
输入输出原语
这些子文件和管道函数处理输入和输出。功能被指定为进行文件描述符管理和I/O活动之间得平衡调节。
设备驱动和分类函数
该章节描述了一个基本的终端接口和一些基本的终端控制函数，如果执行时被提供，所有的异步通信端口都应该支持它，接口是支持网络连接还是异步端口或者两者都支持由完成者定义，一致性文档应该描述那些设备类型被这些接口所支持。本章的一些函数主要应用与进程的控制终端
基于c语言得服务
系统数据库
数据交换格式
时钟和定时器
第三章进程原语
3．1进程的创建和执行
1．进程创建
函数原型：pid_t fork (void)
函数功能：调用时需要引用的头文件是&sys/types.h&,fork()创建了一个新的进程。
2．执行一个文件
函数原型：intexec1(const char *path, const char *arg, …);
intexecv(const char *path, const *char argv[] );
intexecle(const char *path, const char *arg, …);
intexecve(const char *path, const *char argv[], char *const envp[])
intexeclp(const char *file, const char *arg. …);
intexecvp(const char *file, char *const argv[]);
函数功能：exec系列的函数用一个新的进程映像替代了当前的进
程映像，这个新的进程映像创建于一个规则的，可执行文件，叫做新进程映像文件。执行成功无返回值因为调用进程映像以为新的进程映像所覆盖。
3.2进程的终止
进程的终止有两种情况：
（1）从main()函数返回时或者执行exit()或_exit()函数时正常的终止；
（2）被abort()函数请求或者接受到一些信号时不正常的终止；
1．等待进程终止
函数原型：#include&sys/types.h&
#include&sys/wait.h&
pid_twait(int *stat_loc);
pid_twaitpid(pid_t pid,int *stat_loc.int options);
函数功能：wait（）和waitpid（）允许调用进程获得它的一个子进程的状态信息。Wait()函数将挂起调用进程直到获得了它的子进程的状态信息，或者是直到获得一个终止进程信号；如果pid＝－1并且options=0，waitpid()函数功能将和waitpid()相同，否则它的功能将依据pid和options的值而改变。
2.终止一个进程
函数原型：void_exit(intstatus);
函数功能：_exit()函数将终止一个调用进程，该函数不能返回给其调用者
在头文件&signal.h&终声明了sigset_t类型和sigaction结构。完成所定义的信号分三类：必需的信号；任务控制信号；内存保护信号，分别如下表：
符号常量 描述
SIGABRT非正常终止信号
SIGALRM超时信号
SIGFPE错误运算操作
SIGHUP为控制中断所检测到的挂断
SIGILL无效硬件信号的检测
SIGINT交互式信号
SIGKILL终止信号
SIGPIPE写信号
SIGQUIT交互式终止信号
SIGSEGV无效内存引用检测信号
SIGTERM终止信号
SIGUSR1保留信号
SIGUSR2保留信号
作业控制信号
符号常量 描述
SIGCHLD子进程终止或停止
SIGCONT停止后继续
SIGSTOP停止信号
SIGTSTP交互式的停止信号
SIGTTIN从控制终端读
SIGTTOU写到控制终端
内存保护信号
符号常量 描述
SIGBUS获取内存中不确定的部分
每一个进程有一个进程标记（processmask），它定义了一组产生但被阻塞传递的信号集。Sigaction（），sigpromask（），sigsuspend（）
函数控制这个进程标记的行为。
1.送一个信号到进程
函数原型：#include&sys/types.h&
#include&signal.h&
intkill(pid_t pid, int sig)
函数功能：该函数发送一个信号到一个由pid指明的进程或者进程组，sig标志了信号类型，其值是0或者上表中的值。如果发送成功，返回‘0’，否则返回‘1’。
2.操纵信号集
函数原型：#include&signal.h&
intsigemptyset(sigset_t *set);
intsigfillset(sigset_t *set);
intsigaddset(sigset_t *set, int signo);
intsigdelset(sigset_t *set, int signo);
intsigisemeber(const sigset_t *set,int signo);
函数功能：sigsetops源语操纵信号集。他们操作以数字为对象，这些数据由应用程序的地址所指向，而不是以系统所知的信号集为对象。
3.检测和更改信号的行为
函数原型：#include&signal.h&
intsigaction(int sig,const struct sigaction *act,struct sigaction*oact);
函数功能：该函数允许调用函数检查与确定的信号相联系的行为，
参数sig确定了信号，sigaction结构在头文件&signal.h&中被定义，描述了所采取的行为。如果参数act不为null,它指向一个结构，它指定了与信号相联系的行为。如果参数oact不为null，先前与信号相联系的行为将被存储到由oact指向的地方。
4.检查和改变阻塞信号
函数原型：#include&signal.h&
intsigprocmask(int how,xonst sigset_t *set,sigset_t *oset);
函数功能：该函数用来检查和改变调用进程的信号标记（signalmask），如果参数set不为null，它指向一个信号集的用于改变当前的阻塞集。参数how指明了改变方式，参数oset不为null时，先前的信号标记被存储在它所指向的地方，如果参数set为null，则参数how就没有意义了，而且进程的信号标记不能随函数调用而改变。
5.检查未定的信号
函数原型：#include&signal.h&
intsigpending(sigset_t *set);
函数功能：该函数存储一个信号集，这些信号是在被调用进程传输和未定的情况下阻塞的，由参数set所指向。
6.等待一个信号
函数原型：#include&signal.h&
intsigsuspend(const sigset_t *sigmask);
函数功能：该函数用参数sigmask所指向的信号集取代了进程信号标记（signalmask），然后挂起该进程直到接受到一个信号，其行为是执行信号跟踪功能或者是终止该进程。
7.同步接受一个信号
函数原型：
#include&signal.h&
intsigwaitinfo(const sigset_t *set, siginfo_t *info);
intsigtimedwait(const sigset_t *set,siginfo_ *info, const structtimespec *timeout );
函数功能：该函数从参数set所确定的信号集中选择一个未定的信号出来。如果该函数成功，返回一个信号数；否则返回－1。
8.排队一个信号到进程
函数原型：#include&signal.h&
intsigqueue(pid_t pid,int signo, const union sigval value);
函数功能：该函数功能是使由signo确定的信号将参数value所确定的值发送到由pid指明的进程中去。
3.4定时器操作
1．调度警报
函数原型：unsignedint alarm(unsigned int seconds);
函数功能：当参数seconds指定的一段实时时间过去后，该函数将发送一个SIGALRM信号到调用进程。
2.挂起进程的执行
函数原型：intpause(void);
函数功能：该函数挂起一个调用进程直到得到一个信号，这个信号或者执行信号跟踪功能或者是终止该进程。如果是终止进程，该函数不返回；如果是执行信号跟踪功能，则该函数在信号跟踪函数返回后也要返回。
3.延迟进程的执行
函数原型：unsignedint sleep(unsigned int seconds);
函数功能：该函数使当前进程从执行状态转化为挂起状态，直到参数seconds所指定的一段实时时间过去后，或者是一个唤醒信号跟踪功能或终止进程功能的信号到来。该挂起时间由于系统的其他调度活动可能会比要求的时间长。
第三章进程环境
4.1进程标志符
1.获得进程和父进程的ID
函数原型：#include&sys/types.h&
pid_tgetpid(void);
pid_tgetppid(void);
函数功能：getpid（）返回调用进程的进程ID,
getppid（）返回调用进程的父进程ID.
1．获得真实用户，有效用户，真是组，有效组的ID
函数原型：#include&sys/types.h&
uid_tgetuid(void);
uid_tgeteuid(void);
gid_tgetgid(void);
gid_tgetegid(void);
函数功能：getuid（）返回调用进程的真实用户ID,geteuid()返回调用进程的有效用户ID，getgid（）返回调用进程的真实组ID，getegid（）返回调用进程的有效组的ID。
2.设置用户和组的ID
函数原型：#include&sys/types.h&
intsetuid(uid_t uid);
intsetgid(gid_t gid);
函数功能：这两个函数分别根据进程的权限设置真实用户ID,有效用户ID，真实组ID，有效组ID。
3.获得辅助组ID
函数原型：#include&sys/types.h&
intgetgroups(int gidsetsize.gid_t grouplist[]);
函数功能：该函数在队列的组列表中填入调用进程的辅助组ID。参数grouplist确定了组列表中的元素个数。
4.获得用户名
函数原型：char*getlogin(void)
函数功能：该函数返回一个指针，指向与调用进程相关的用户名。
1.获得进程组ID
函数原型：#include&sys/types.h&
pid_tgetpgrp(void);
函数功能：该函数返回调用进程的进程组ID。
2.创建会议并且设置进程组ID
函数原型：#include&sys/types.h&
pid_tsetsid(void)
函数功能：如果调用进程不是进程组的引导者，则该函数将创建一个新的会议。该调用进程应该为新会议的会议引导者，应该为新进程组的引导，应该没有控制终端。进程组的ID应该等于该调用进程的ID。
3.为作业控制设置进程组ID
函数原型：#include&sys/types.h&
intsetpgid(pid_t pid,pid_t pgid);
函数功能：如{_POSIX_JOB_CONTROL}被定义，则该函数用来加入已经存在的进程组或者创建一个新的进程组。
4.4系统标志
1.获得系统名
函数原型：#include&sys/utaname.h&
intuname(struct utsname *name);
函数功能：该函数存储了鉴别当前操作系统的信息。
1得到系统时间
函数原型：#include&time.h&
time_ttime(time_t *tloc);
函数功能：该函数返回自从一时间点以来的某个时间值，以秒为单位。参数tloc指向一个时间值所存储的地方。
2.获得进程时间
函数原型：#include&sys/times.h&
clock_ttimes(struct time *buffer);
函数功能：参数buffer指向一个结构，该函数向该结构填写有关时间的信息。Clock_t和tms结构在&sys/times.h&中定义。
4．6环境变量
1.获取环境
函数原型：#include&stdlib.h&
char*getenv(const char *name);
函数功能：该函数在环境列表查找字符串name=value,返回指向value的指针。如果没有找到，则返回null。
4.7终端标志
1．产生终端路径
函数原型：#include&stdio.h&
charIctermid(char *s);
函数功能：该函数产生一个字符串，作为路径名，提交到当前进程的当前控制终端。
2．确定终端设备名
函数原型：char*ttyname(int fildes);
intisatty(int fildes);
函数功能：ttyname（）返回一个指针指向一个字符串，它包含了与文件描述符fildes相关的终端名；如果fildes是一个有效的与终端联系的文件描述符，isatty（）返回“1”，否则返回“0”。
4．8可配置的系统变量
1．获得可配置的系统变量
函数原型：#include&unistd.h&
longsysconf(int name);
函数功能：该函数提供了一个应用方法来决定可配置系统变量的当前值。参数name代表了所查询的系统变量。
第五章文件和目录
1．目录的入口形式
头文件&dirent.h&定义了一个结构和目录程序用到的类型，没有确定的文件内部格式。Readdir()返回了一个指针指向一个类型对象structdirent。
2．目录操作
函数原型：#include&sys/types.h&
#include&dirent.h&
dir*opendir(const char *dirname);
structdirent *readdir(dir *dirp);
voidrewinddir(dir *dirp);
intclosedir(dir *dirp);
函数功能：opendir()根据参数dirname打开一个目录流；readdir（）返回一个指针，它指向一个目录流中当前位置的目录入口，目录流由参数dirp指向；rewinddir（）重置目录流的位置到目录的起点；closedir（）关闭目录流，如成功，则返回“0”值。
5．2工作目录
1改变当前的工作目录
函数原型：intchdir(const char *path);
函数功能：path指向目录的路径名。该函数使命名的目录成为当前的工作目录。
2获得工作目录路径名
函数原型：char*getcwd(char *buf,size_t size);
函数功能：该函数复制当前工作目录的绝对路径名到buf所指向的队列中。
5．3基本文件的创建
1打开一个文件
函数原型：#include&sys/types.h&
#include&sys/stat.h&
#include&fcnt1.h&
intopen(const char *path, int oflag,…);
函数功能：open（）在文件和文件描述符之间建立了一个连接，它创建了一个指向一个文件的打开文件描述，参数path指向文件的路径名。
2创建一个新文件或者重写一个已经存在的文件
函数原型：#include&sys/types.h&
#include&sys/stat.h&
#include&fcnt1.h&
intcreat(const char *path, mode_t mode);
函数功能：该函数调用creat（path，mode）相当于open（path，o_wronly/o_creat/o_trunc,mode）;
3设置文件的创建标记
函数原型：#include&sys/types.h&
#include&sys/stat.h&
mode_tumask(mode_t cmask);
函数原型：umask()设置进程的文件模式创建标记到cmask，并且返回原来的标记值。
4连接到一个文件
函数原型：intlink(const char *existing,const char *new);
函数功能：参数existing指向路径名来命名存在文件，参数new指向一个路径名，它命名了一个创建的新的目录入口。该函数为已存在的文件自动的创建一个新的连接，并且将文件连接数加1。
5．4特殊文件创建
1生成一个目录
函数原型：#include&sys/types.h&
#include&sys/stat.h&
intmkdir(const char *path,mode_t mode);
函数功能：该函数依据参数path创建一个新的目录。新目录的允许位根据mode初始化。
2创建一个FIFO类型的文件
函数原型：#include&sys/types.h&
#includesys/stat.h&
intmkfifo(const char *path,mode_t mode);
函数功能：mkfifo（）创建一个新的fifo类型文件，它由path指向的路径名命名。
5．5文件的移动
1移动目录入口
函数原型：intunlink(const char *path);
函数功能：该函数移去由参数path指向得路径名所命名得连接并将连接数减去1。
2移去一个目录
函数原型：intrmdir(const char *path)
函数功能：
3重命名一个文件
函数原型：intrename(const char *old,const char *new);
函数功能：该函数改变一个文件的名字，参数old指向被重命名文件的路径名，参数new指向文件的新路径名。
5．6文件特征
5．7可配置路径名变量
第六章输入与输出源语
1创建内进程通道
函数原型：intpipe(int filedw[2]);
函数功能：该函数创建一个管道并且创建两个文件描述符，一个是fildes[0],一个是fildes[1],它们分别指的是‘读’与‘写’的管道端。
6．2文件描述符控制
1复制一个打开文件描述符
函数原型：intdup(int fildes);
intdup2(int fileds,int fileds2);
函数功能：这两个函数为fcntl（）服务提供了两个选择的接口，用到了F_DUPFD命令。
6．3撤除文件描述符
1关闭一个文件
函数原型：intclose (int fildes);
6．4输入和输出
函数原型：ssize_tread(int fildes,void *buf,size_t nbyte);
函数功能：
函数原型：ssize_twrite(int fildes,const void *buf,size_t nbyte);
函数功能：
6．5一个文件的控制操作
1文件控制操作的数据定义
头文件&fcnt1.h&为fcntl（）和open（）定义了一下的要求和参数：
fcntl（）的_cmd值
函数原型：#clude&sys/types.h&
#clued&unistd.h&
#include&fcntl.h&
intfcntl(int fildes,int cnd,…);
函数功能：fcntl()为打开的文件提供了一系列控制，参数fildes是一个文件描述符。Cmd决定了控制的内容。
3读/写文件偏移量的重新定位
函数原型：#include&sys/types.h&
#include&unistd.h&
off_tlseek(int fildes,off_t offset,int whence);
函数功能：lseek（）为fildes所指定的文件重新设置偏移量。
6．6文件同步
1文件的状态同步
函数原型：#include&unistd.h&
intfsync(int fildes);
函数功能：该函数用来暗示所有的文件描述数据被传输到了存储设备上。
2文件数据的同步
函数原型：#include&unistd.h&
intfdatasync(int fildes);
函数功能：该函数迫使当前所有排队的I/O操作进入同步I/O状态。
6．7异步输入与输出
1●异步输入与输出的数据定义
头文件&aio.h&能使&sys/types.h&，&signal.h&，&time.h&
和&fcntl.h&中的符号可见。
● 异步I/O控制块
异步I/O控制块结构aiocb在许多异步I/O接口中使用，它在&aio.h&中定义。
●主要常量
函数原型：#include&aio.h&
intaio_read (struct aiocb *aiocbp);
函数功能：aiocbp-&io_nbytes,表示读的字节数；aiocbp-&aio_fildes，表示读的文件；aiocbp-&aio_buf,表示读到的缓冲区。
函数原型：#include&aio.h&
intaio_write(struct aiocb *aiocbp);
函数功能：参数表示同上。
4列出直接I/O
函数原型：#include&aio.h&
intlio_listio(int mode,struct aiocb *const list[],int nent,structsigevent *sig);
函数功能：该函数允许用一个函数调用初始化一个I/O请求
5得到异步I/O操作的错误状态
函数原型：#include&aio.h&
intaio_error(const struct aiocb *aiocbp);
函数功能：该函数返回aiocbp指向的结构所表示的错误状态。
6得到异步I/O操作的返回状态
函数原型：#include&aio.h&
ssize_taio_return(struct aiocb *aiocbp);
函数功能：
7删除异步I/O请求
函数原型：#include&aio.h&
intaio_cancel (int fildes,struct aiocb *aiocbp);
函数功能：参数fildes是文件描述符，参数aiocbp指向异步I/O控制块上的请求删除部分。
8等待异步I/O请求
函数原型：#include&aio.h&
intaio_suspend(const struct aiocb *const list[],int nent,const structtimespec *timeout);
函数功能：标准定义该函数挂起调用进程直到至少一个list指向
的异步I/O操作完成，或者一个信号中断了一个函数，
或者超时了（timeout指定）。
9异步文件同步化
函数原型：#include&aio.h&
intaio_fsync(int op,struct aiocb *aiocbp);
函数功能：该函数迫使所有与（参数aiocbp指向的）结构aiocb中aio_fildes所指定的文件相关异步I/O操作进入同步状态。
第七章设备和面向类的函数
7．1基本的终端接口
●当一个终端文件被打开，通常它将引起进程等待直到连接被建立。
一个终端可以具有与它相关的前台进程组，它发挥特定的角色，后面会讲到。
● 控制终端
● 终端存取控制
● 输入操作和读进程
● 规范的输入操作
● 非规范模式的输入操作
● 写数据和输出处理
● 特殊的符号(INTR,QUIT,ERASE,KILL…)
modem断掉连接
● 关闭终端设备文件
2可设置的参数
●termios机构
该结构在&termios.h&中定义，在控制特定的终端I/O特性中要用到。
●输入模式
termiosc_iflap值域
标记名 描述
BRKINT信号中断
输入时将CR映射到NL
IGNBRK忽略中断状态
IGNPAR忽略奇偶错误
INLCR输入时将NL映射到CR
INPCK输入奇偶校验使能
ISTRIPStrip字符
开始/停止输入控制使能
开始/停止输出控制使能
产生奇偶错误
●输出模式
●控制模式
标记名 描述
忽略modem状态行
每个字节的位数
发送一个或两个停止位
在最后的关闭中挂起
奇校验使能
PARODD奇校验或偶校验
●本地模式
termiosc_lflag
标记名 描述
ECHO响应使能
ECHOE响应ETASE
ECHOK响应KILL
ECHONL响应’\n’
ICANON规范输入
IEXTEN扩展函数使能
ISIG信号使能
NOFLSH中断，停止或挂起后关掉flush
TOSTOP为后台输出发送SIGTTOU
●特殊的控制字符
这些特殊的控制字符值在队列c_cc中定义，分为规范和非规范两种模式。
●波特率值
3波特率函数
函数原型：#include&termios.h&
speed_tcfgetospeed(const struct termios *termios_p);
intcfsetospeed (struct termios *termios_p,speed_t speed);
speed_tcfgetispeed(const struct termios *termios_p);
intcfsetispeed(struct termios *termios_p,speed_t speed);
函数功能：以上这些接口被用来在termios结构获得和设定输入与输出的波特率值。
7．2基本的终端接口控制函数
1获得并设定状态
函数原型：#include&termios.h&
inttcgetattr(int fildes,struct termios *termios_p);
inttcsetattr(int fildes,int optional_actions,const struct termios *termios_p);
函数功能：tcgetattr（）获得fildes所确定的文件的参数并将其存储在t’erops_p所指向的结构中；tcsetattr（）将设置参数。
2行控制函数
函数原型：#include&termios.h&
inttcsendbreak(int fildes,int duration);
inttcdrain(int fildes);
inttcflush(int fildes,int queue_selector);
inttcflow(int fildes,int action)’
函数功能：如果终端使用异步连续数据传输，tcsendbreak（）引起在一段时间内连续的‘0’位传输；tcdrain（）等待直到输出传输完毕；tcflush（）和tcflow（）是溢出的相关处理。（参考第212页）
3取得前台进程组的ID
函数原型：#include&sys/types.h&
pid_ttgetpgrp(int fildes);
4设置前台进程组ID
函数原型：#include&sys/types.h&
inttcsetpgrp(int fildes,pid_t pgrp_id);
功能：如果进程支持控制终端，该函数设置与终端相关的前台进程组ID到pgrp_id。
第八章基于C语言的服务
8.1参考的C语言规范
1时间函数的扩展
2setlocale（）函数的扩展
函数原型：#include&locale.h&
char*setlocale(int category,const char *locale);
函数功能：该函数根据参数category和locale设置，更改或者查询进程现场。
8．2C语言输入/输出函数
1映射一个流指针到一个文件描述符
函数原型：#include&stdio.h&
函数功能：该函数返回一个与流相关的整型文件描述符。
2根据一个文件描述符打开一个流
函数原型：#include&stdio.h&
FILE*fdopen(int fildes,const char *type);
函数功能：该函数联合一个流和一个文件描述符。
3其他文件类型函数之间的相互作用
一个单一的文件描述说明可以通过流和文件描述符访问，流
或者是文件描述符被称作位打开文件的句柄，一个打开文件说明
可以有多个句柄。句柄可以在不影响重要的打开文件说明的情况
下被创建和删除，创建如fcntl().dup(),fdopen(),fileno(),fork();删除
如fclose(),close()。
（1）fopen（）随着open（）的调用分配描述符，基础函数为
open（）。
（2）fclose（）：该函数完成在与FILE流相关的，对文件描述符的close（）功能。
（3）freopen（）：具有fclose（）和fopen（）的特点。
（4）fflush（）：如果流可写或者缓存数据还没有写入文件时，
该函数标记下基础文件st_ctime和st_mtime的
值。
（5）fgetc（），fgets（），fread（），getc（），getchar（），gets
（），scanf（），fscanf（）：这些函数标记更新的st_atime值。
基础函数是read（）和lseek（）。
（6）fputc(),fputs(),fwrite(),putc(),putchar(),puts(),printf(),fprintf():
从以上任一个函数的成功执行到下一个调用（在同一个流中的fflush（）或fclose（）或exit（）或abort（）），记下更新的st_ctime和st_mtime值。基础函数是write（）和
lseek（）。
（7）fseek（），rewind（）：如果流可写或者缓存数据还没有写
入文件时，该函数标记下文件更新的st_ctime和st_mtime值。基础函数是
lseek（）和write（）。
（8）perror（）：记下与标准错误流相关的文件。
（9）tmpfile（）：fopen（）执行后为文件分配文件描述符。
ftell():基础文件是lseek（）。执行fflush（）后执行该
函数的结果与执行fflush前执行该函数的结果相同。
（11） 报错
exit（），abort（）：exit（）终止进程的时候要关闭流，
abort（）只终止进程对流没有影响。
4文件操作-----remove（）函数
该函数和unlink（）函数的功能一样。
8．3其他的C函数
1非局部跳转
函数原型：#include&setjmp.h&
intsigsetjmp(sigjmp_buf env,int savemask);
voidsiglongjmp(sigjmp_buf env,int val);
函数功能：sigsetjmp（）宏要与标准中setjmp（）宏的定义一致，如果参数savemask不为“0”，sigsetjmp（）就要保存当前的信号标记作为调用环境的一部分。Siglongjmp（）同理。
2设置时间域
函数原型：#include&time.h&
voidtzset(void);
函数功能：该函数用环境变量TZ的值来设定时间变化信息。
第九章系统数据库
9．1系统数据库
本章描述了两个数据库：组数据库和用户数据库。
组数据库包括的信息有：组名，组的数字ID,组中的用户列表；
用户数据库包含的信息有：用户名，用户的数字ID，组的数字ID,初始化的工作目录，和初始化的用户程序。
9．2数据库的访问
1组数据库的访问
函数原型：#include&sys/type.h&
#include&grp.h&
structgroup *getgrgid(gid_t gid);
structgroup *getgrnam(const char *name);
函数功能：getgrid（）和getgrnam（）返回指针，它指向一个struct
group类型的对象，包含了组数据库的入口。
2用户数据库的访问
函数原型：#include&sys/types.h&
#include&pwd.h&
structpaswd *getpwuid(uid_t uid);
structpasswd *getpwnam(const char *name);
函数功能：getpwuid（）和getpwnam返回一个指针，指向struct
passwd类型的一个对象，它包含了用户数据库的入
第十章数据交换形式
10．1归档/交换文件格式
1扩展的tar格式
2扩展的cpio格式：面向字节的归档格式，包括了文件头，文件名和文件内容。
3大流量：该格式被看作是字节流。
第十一章同步
11．1信号量特征
头文件&semaphore.h&定义了sem_t类型，它用于信号量操作中。sem_t代表了信号量，用文件描述符能够实现这些信号量，应用程序能够打开至少{OPEN_MAX}这么多的文件和信号量。标准中，头文件&semaphore.h&能使头文件&sys/types.h&和&fcntl.h&中的符号可见。
11．2信号量函数
1初始化一个未命名的信号量
函数原型：#inxlude&semaphore.h&
intsem_init (sem_t *sem,int pshared,unsigned int value);
函数功能：如果{_POSIX_SEMAPHORES}定义了：该函数被用
来初始化sem引用的未命名信号量。在成功调用该函
数以后，在接下来的sem_wait()，sem_trywait(),sem_post(),sem_destroy()的调用中，该信号量将被用到。如果参数pshared不为零，信号量将在进程中被共享，任何可以访问信号量sem的进程都可以使用sem。只有sem能被用来进行同步。如果参数pshared为零，则结构不确定。如果标准中未定义，可以由执行者来支持该函数。
2删除一个未命名信号量
函数原型：#include&semaphore.h&
intsem_destroy(sem_t *sem);
函数功能：如果{_POSIX_SEMAPHORES}定义了，该函数用来删除sem引用的未命名信号量，只有在sem_init（）中创建的信号量才能被该函数删除。
3初始化/打开一个命名信号量
函数原型：#include&semaphore.h&
sem_t*sem_open(const char *name,int oflag,…);
函数功能：如果{_POSIX_SEMAPHORES}定义了，该函数在进程和命名信号量之间创建一个链接。接着调用带有信号量名name的该函数，进程引用与name相关的信号量。该信号量在一些函数的调用中用到，如sem_wait(),sem_trywait(),sem_post,和sem_close()。信号量一直可用知道调用函数sem_close(),_exit,exec()关闭它。参数oflag控制是否信号量由sem_open（）创建或者仅被它访问。
4关闭一个命名信号量
函数原型：#include&semphore.h&
intsem_close(sem_t *sem);
函数功能：如果{_POSIX_SEMAPHORES}定义了，该函数用来提示调用进程已经完成使用sem所指明的信号量。该函数释放系统资源，这些资源被拥有该信号量的进程占有。
5移走一个命名信号量
函数原型：#include&semaphore.h&
intsem_unlink(const char *name);
函数功能：该函数将移走被字符串name命名的信号量。如果该信号量当前被其他进程引用，则该函数对信号量状态没有影响。如果一个和更多的进程打开了该信号量，则销毁该信号量被延迟知道所有的信号量被sem_close()，_exit(),exec关闭。
6锁定一个信号量
函数原型：#include&semaphore.h&
intsem_wait (sem_t*sem);
intsem_trywait(sem_t *sem);
函数功能：sem_wait()锁定sem引用的一个信号量，对该信号进行锁定操作。如果信号量为“0”，调用进程将不会返回直到锁定了这个信号量或者被一个信号中断。Sem_trywait()只能在信号量当前没被锁定的情况下锁定它，否则将不会锁定信号量。成功返回，信号量的状态将被锁定直到sem_post()被调用并且成功返回。
7解锁一个信号量
函数原型：#include&semaphore.h&
intsem_post(sem_t *sem);
函数功能：该函数通过对一个信号量的解锁操作解锁一个被sem引用的信号量。如果该操作的结果，信号量值为正数，则没有进程被锁定来等待一个信号量解锁，信号量值是单一的增加。如果信号量值为“0”，则进程被锁定来等待一个信号量被允许从sem_wait()成功返回。
8取得一个信号量值
函数原型：#include&semaphore.h&
intsem_getvalue(sem_t *sem,int *sval);
函数功能：该函数更新参数sval所引用的位置，在不改变信号量状态的情况下得到信号量值。更新的值代表了一个确切的值，它产生在调用中的一个不定时刻，但它返回给调用进程是不一定需要信号量的确定值。如果sem被锁定，则sem_getvalue（）返回的值为0，或者负数，它代表了等待信号量的进程数。
第十二章 内存管理
该章节描述了进程内存锁定，内存映象文件，和共享内存工具。
内存锁定和内存映象文件以页的方式定义。执行者可以据据页大小的规范限制和排列锁定和映象范围。页的大小，以字节为单位，是一个可配置系统变量。默认为1B。
内存锁定保证了一部分地址空间的驻留。
12．1内存锁定函数
1锁定/解锁进程地址空间
函数原型：#include&sys/mman.h&
intmlockall(int flags);
intmunlockall(void);
函数功能：mlockall（）使进程地址空间所映射的所有页面成为内存驻留区，直到解锁或者进程退出或者execs另一个进程映象。参数flags决定了是否被锁定的页面是由当前，（将来，或者两者都是）的进程地址空间映射的。Munlockall（）解锁当前所有的进程地址空间映射页面。所有映射到进程地址空间的页面，调用了该函数，将不会被锁定，除非有中断调用mlockall()确定MCL_CURRENT，或者并发调用mlockall()确定MCL_CURRENT。
2锁定/解锁一连续的地址空间
函数原型：#include&sys/mman.h&
intmlock(const void *addr,size_t len);
intmunlock(const void *addr,size_t len);
函数功能：mlock（）使一个范围的进程地址空间成为内存驻留
区（addr决定了空间的起始地址，len决定了空间长
度）直到解锁或者进程退出或者execs另一个进程映
象；munlock（）解锁一个范围的进程地址空间（addr
决定了空间的起始地址，len决定了空间长度);
12.2内存映象函数
1映象进程地址到一个内存目标
函数映象：#include&sys/mman.h&
void*mmap(void *addr,size_t len,int prot,int flags,int fildes,off_t off);
函数功：该函数在一个进程的地址空间和内存对象间创建一个映
射，调用格式如：pa=mmap(addr,len,prot,flags,fildes,off);
pa代表进程进程地址空间的地址，由执行者定义（addr
和flags），len表示空间长度，fildes代表内存对象，off
表示偏移量。函数成功调用返回pa，空间地址范开始
与pa，长度为连续的len个字节；内存对象开始与off，
长度为len字节。参数prot决定了读，写，执行，或一
些映射数据的访问活动的集合。
2取消以前映射地址的映射关系
函数原型：#include&sys/mman.h&
intmunmap(void *addr,size_t len);
函数功能：该函数移去任何包含有进程地址空间的页面的映射关
系，该进程地址空间起始于addr，长度为len字节。
3改变内存保护
函数原型：#include&sys/mman.h&
intmprotet(const void *addr,size_t len,int prot);
函数功能：该函数更改访问的保护活动，由参数prot确定。访问对象是一部分进程地址空间，起始于addr，长度为len字节。
4内存对象同步
函数原型：#inxlude&sys/mman.h&
intmsync(void *addr,size_t len,int flags);
函数功能：该函数将所有更改了的数据写到拥有存储的地方，它包含了进程地址空间，起始于addr，长度为len字节。如果没有这样的存储区域存在，则给函数没有作用。该函数须保证写操作的完成符合所定义的同步I/O数据的一致完成性。参数flags确定了写的同步/异步性。
12．3共享内存函数
1打开一个共享内存对象
函数原型：include&sys/mman.h&
intshm_open(const *name,int oflag,mode_t mode);
函数功能：该函数在共享内存对象和文件描述符之间创建了一个连接。它创建了一个打开文件描述涉及到共享内存对象，并且创建了一个文件描述符指向这个打开文件描述。这个文件描述符可悲其他函数用来指向共享内存对象，参数name指向共享内存对象名。如函数调用成功，则返回一个共享内存的文件。文件状态和文件访问模式根据oflag的值来设定。
2移去一个共享内存对象
函数原型：intshm_unlink(const char *name);
函数功能：该函数移去由name命名的共享内存对象。如果一个或者多个对共内存的引用在对象断开连接的同时退出的话，这个名字应在shim_unlink()返回之前移走，但是对内存对象的移走须延迟到所有对共享内存对打开和映射引用被移去后。
十三章 执行调度
13.1调度参数
一个调度参数结构sched_param包括了调度策略所支持的执行者
所需要的调度参数，它在头文件&sched.h&中定义。执行者可根据规
对该结构进行扩展。
13.2调度策略
该章所阐述的调度术语是从概念模型上定义的，它包含了一组进程列表。这个模型只讨论了可运行进程的处理器调度，但是它注重了在其他资源考虑到处理器调度策略的情况下，增强了实时操作的可预见性。在这里，概念上讲是一个进程列表一个策略。调度策略的目的就是对这一组列表定义允许的操作（例如，在进程列表之中和之间移动进程）。每一个进程应由相关的调度策略和优先级，于每一个策略相关的是一个优先级范围。
1SCHED_FIFO
该策略是一种先进先出的调度策略。如果正在执行的进程是被抢占的进程，则他应该在进程列表头；如果一个锁定的进程变成可执行进程，它就进入进程列表尾；当执行进程调用sched_setscheduler()，则函数中确定的进程被改为指定的策略；当执行进程调用sced_setparam()，进程的优先级根据参数param被修改，如果改进程是正在执行和可执行，则它将进入进程列表尾；当正在执行的进程调用seced_yield()，进程进入列表尾。
该策略与上面的策略不同的是，如果执行中检测到进程的执行时间已经到达或超过了sched_rr_get_interval()所返回的时间片，进程就进入列表尾并且进程列表头移动一个进程进入执行状态。
3SCHED_OTHER
13.3进程调度函数
1设置调度参数
函数原型：#include&sched.h&
intsched_setparam(pid_t pid,const struct sched_param *param);
函数功能：pid指明了进程，param指向了sched_param结构，该结构设定了进程的调度参数。如果pid＝0，调度参数为调用进程设定。如果pid指定的进程的优先级高于正在指向的进程并且该进程可执行，则抢占现在正在运行的进程。如果当前的策略不是前面将的三种方式，则由执行者定义。
2取得调度参数
函数原型：#include&sched.h&
intsched_getparam(pid_t,struct sched_param *param);
函数功能：该函数返回调度参数，如果一个pid进程退出并且调用进程允许，则ID等于pid的进程返回其调用参数。如果pid＝0，则返回调用进程的调度参数。
3设置调度策略和调度参数
函数原型：#include&sched.h&
intsched_setscheduler(pid_t pid,int policy,const struct sched_param*param);
函数功能：该函数设置进程的调度策略和调度参数，pid表示进程，policy指明策略，参数param指向的sched_param结构指明了调度参数。执行者可要求请求进程能允许设定自己或其他进程的调度参数。
4取得调度策略
函数原型：#include&sched.h&
intsched_getscheduler(pid_t pid);
函数功能：该函数返回pid进程的调度策略，其返回值在头文件&sched.h&中定义。
5放弃处理器
函数原型：#include&sched.h&
intsched_yield(void);
函数功能：该函数迫使正在执行进程放弃处理器直到重新进入进程列表头。
6获得调度参数范围
函数原型：#incude&sched.h&
intsched_get_priority_max(int policy);
intsched get_priority min(int policy);
intsched_rr_get_interval(pid_t pid,struct timespec *interval);
函数功能：sched_get_priority_max()和sched_get_priority_min()返
回policy调度策略相应的最大最小值。Sched_rr_get
_interval()更新interval参数引用的timespec结构，包
含了当前进程执行的时间限制。
第十四章时钟和定时器
14．1时钟和定时器的数据定义
头文件&time.h&定义了时间设备用到的类型和主要常量。
1时间值的规格结构
一个时间值结构timespec确定了单一时间值并且包括了以下值：
成员类型 成员名 描述
time_ttv_sec seconds
longtv_nsec nanosenconds
执行者可对他做扩展，tv_nsed成员要大于等于零时才可用。
时间值结构itimerspec确定了一个初始化的定时器和各进程定时器函数用到的重复间隔。结构包括：
成员类型 成员名 描述
Structtimespec It_interval Timer period
Structtimespec It_value Timer expiration
执行者也可以对其做扩展。
2定时器活动唤醒控制块
为了使完成支持实时信号扩展功能，各进程定时器被创建通过排列实时扩展信号来通知定时器超时的进程。Sigevent结构在头文件&signal.h&中定义，用来创建一个这样的定时器。
在&sys/types.h&中定义。
在&time.h&中定义：
CLOCK_REALTIME系统范围的实时时钟标志
TIMER_ABSTIME flag指定的时间对于时钟是“完全”的
14．2时钟和定时器函数
函数原型：#include&time.h&
intclock_settime(clockid_t clock_id,const struct timespec *tp);
intcoock_gettime(clockid_t clock_id,struct timespec*tp);
intclock_getres(clockid_t clock_id,struct timespec *res);
函数功能：clock_settime()设置特定时钟，clock_id,到tp指定的值。
Clock_gettime()返回当前的tp值，即时钟，clock_id；
调用clock_getres()可以得到时钟的决定值，该值由执行
者定义而不由进程设定。如果res不为空，则该值被存
储在res指向的地方，如果res为空，则时钟决定值不
被返回。一个时钟可以是系统范围的，对于所以的进程可见，所有的执行者要支持CLOCK_REALTIME的clock_id。对于这个时钟。Clock_gettime()返回的和clock_settime()确定的值代表了从一个时间点开始的时间长度，执行者也可以支持附加的时钟。借助clock_settime()设定时钟的影响由执行者定义。设置特殊时钟的权限也有执行者定义。
2创建一个总进程定时器
函数原型：#include&signal&
#include&time.h&
inttimer_create(clockid_t clock_id,struct sigevent
*evp,timer_t*timerid);
函数功能：timer_create()创建一个总进程定时器，用来指明时钟，clock_id,作为计时基础。该函数在timerid指向的地方返回一个timer_t类型的定时器ID，该ID在调用进程中必须是唯一的直到定时器被删除。参数evp如果不为空，则指向一个sigevent结构，定义了定时器超时时出现的异步通知。结构中sigev_notify为SIGEV_SIGNAL时，结构就包括了超时时送往进程的信号数和应用数据；如果sigev_notify为SIGEV_NONE,则不发送任何通知；sigev_notify其他的值由完成者自行定义。总进程的定时器不被其子进程通过fork（）继承，它应该被exec撤销。
3删除一个总进程定时器
函数原型：#include&time.h&
inttimer_delete(time_t timerid);
函数功能：该函数删除一个指定的定时器，timerid，该定时器是在以前的timer_create（）中创建的。
4总进程定时器
函数原型：
#include&time.h&
inttimer_settime(timer_t timerid,int flags,const struct itimerspec*value,struct itimerspec *ovalue);
inttimer_gettime(timer_t timerid,struct itimerspec *value);
inttimer_getoverrun(timer_t timerid);
函数功能：timer_settime()设置时间直到下一个timerid指定的定时器终止。如果该函数调用时定时器已经被装备，该调用则重置时间直到value确定的下一次终止。如果value的it_value成员为零，定时器被解除。如果flag没有设定为TIMER_ABSTIME,则定时器从调用开始在it_value十亿分之一秒内超时；如果设定为TIMER_ABSTIME,该函数表现为时间直到下一次超时被设定为it_value指定的绝对时间和与timerid相联的时钟值的差值。定时器的再装由value的it_interval成员值来设定。如果参数ovalue不为空，该函数被存储在ovalue引用的地方。该函数要存储时间累计值直到timerid指定的定时器终止或重装定时器值到value参数。在任一时刻，仅有一个单一信号被派了在指定的定时器的进程中。如果支持实时信号扩展，timer_getoverrun()返回定时器终止的溢出值。
函数原型：#include&time.h&
intnanosleep(const struct timespec *rqtp,struct timespec *rmtp);
函数功能：该函数使当前执行的进程挂起直到参数rptp指定的时
间间隔到达或者信号被送到调用进程并且其行为就
是唤醒信号跟踪功能或者使终止进程。挂起时间也许
要比要求时间长是因为参数值向上舍入成一个整数或者是因为系统对其他活动的调度。但是除非被信号打断，挂起时间不会少于tqtp值，这是系统时钟，CLOCK_REALTIME测量的。
第十五章消息传递
15．1消息队列的数据定义
头文件&mqueue.h&定义了以下执行者定义的类型：
mqd_t：用于消息队列描述符
头文件&mqueue.h&定义了以下执行者定义的结构：
structsigevent：
3.3中定义。mq_attr用来设定消息队列参数。
structsigevent结构包含了至少以下的成员：
类型 成员名 描述
longmq_flags
消息队列标志
longmq_maxmsg
最大消息数
longmq_msgsize
消息的最大长度
longmq_curmsgs
当前排列的消息数
执行者可作扩展。
15．2消息传递函数
1打开消息队列
函数原型：#include&mqueue.h&
mqd_tmq_open(const char *name,int oflag,…);
函数功能：该函数在进程和消息队列之间建立连接。它创建了一个消息队列描述符指向消息队列。参数oflag请求对消息队列发送或接收所需信息。如果调用进程承认对相应保护文件的读写请求，则对接收或发送消息的请求允许被通过。
2关闭一个消息队列
函数原型：#include&mqueue.h&
intmq_close(mqd_t mqdes);
函数功能：该函数撤销消息队列描述符（mqdes）和消息队列之间的关系。如果进程成功的配属了mqdes表示的消息队列通知请求，则这个配属关系被撤销，该消息队列可用于其他进程来配属通知。
3移去一个消息队列
函数原型：#include&mqueue.h&
intmq_unlink(const char *name);
函数功能：该函数移去路径名name指向的消息队列。如果该调用成功，并且flag没有设为O_CREATE，则mq_open()对于同一个name将会失败。所有对该队列的引用撤销后，该队列才能被关闭。该函数调用不会被阻塞指定所有的引用被关闭。
4发送一个消息到消息队列
函数原型：#include&mqueue.h&
intmq_send(mqd_t mqdes,const char *msg_ptr,size_t mag_len,unsigned intmsg_prio);
函数功能：该函数添加参数msg_ptr指向的消息到mqdes指定的
消息队列中去。参数msg_len表示消息长度，以字节
为单位，该参数应小于等于消息队列的mq_msgsize
参数，否则调用失败。如果消息队列没有满，则该函
数的功能就是插入消息到消息队列的指定位置，这个
位置邮msg_prio参数指定。msg_prio大者先插入队
列，msg_prio的值应小于等于{MQ_PRIO_MAX}。
如果消息已满并且O_NONBLOCK没有设定，该函
数阻塞一直到空间可用或者mq_send（）被信号中断。
如果空间可用时，多于一个进程在等待发送则按优先
级，等待最久的进程先发送它的信息。如果O_NON
BLOCK被设定，并且队列已满，则函数返回error。
5从消息队列接受一条消息
函数原型：#include&mqueue.h&
ssize_tmq_receive(mqd_t mqdes,char *msg_ptr,size_t msg_len,unsigned int*msg_prio);
函数功能：该函数接受mqdes确定的消息队列中最久优先级最高
的消息，对参数值的限制同上。所选消息从队列移出，
复制到msa_ptr指向的缓冲区。如果参数msg_prio不
为空，则指定消息被存储在msa_prio所引用的地方。
如果消息队列为空，并且O_NONBLODK没有设定，
该函数阻塞直到消息排列入队列中或者该函数被信
号中断。当有多个进程在消息到达队列后请求接受，
则优先级原则与上相同。
6通知一个进程队列中的一条信息可用
函数原型：#include&mqueue.h&
intmq_notify(mqd_t mqdes,const struct sigevent *notification);
函数功能：如果参数notification不为空，函数记录下调用进程被
通知空的消息队列（由消息队列描述符mqdes相联）
中有一条消息到来。当消息队列从空到非空时，一条
通知消息将发送到进程中，在任一时刻，只有一个通
知消息被一个消息队列记录。如果notifiction为空并
且进程当前被指定的队列记录，则已存在的记录被移
7设置消息队列参数
函数原型：#include&mqueue.h&
intmq_setattr(mqd_t mqdes,const struct mq_attr *mqstat,struct mq_attr*omqstat);
函数功能：该函数用来设置与mqdes指定的消息队列相关的参数。
mq_attr结构中的mq_maxmsg,mq_magsize,mq_curmsgs
成员被mq_setattr()忽略。如果omqstat为非空，则该函
数被存储，由omqstat指明存储位置。
8得到消息队列参数
函数原型：#include&mqueue.h&
intmq_getattr(mqd_t mqdes,struct mq_attr *mqstat);
函数功能：该函数用来取得状态信息和与mqdes消息队列相关的
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/novagx/archive//2077561.aspx
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：96271次
积分：1324
积分：1324
排名：千里之外
原创：13篇
转载：152篇
(1)(1)(1)(3)(2)(12)(13)(15)(3)(8)(1)(1)(4)(1)(1)(6)(3)(5)(8)(6)(1)(3)(1)(7)(2)(2)(1)(7)(2)(2)(4)(8)(11)(18)(2)