【Linux】延时函数sleep、usleep、nanosleep、select、pselect的比较

最新推荐文章于 2024-04-07 15:56:51 发布
最新推荐文章于 2024-04-07 15:56:51 发布
阅读量3.9k 收藏 12
点赞数
分类专栏： linux
linux 专栏收录该内容
160 篇文章 ¥69.90 ¥99.00
订阅专栏
本文介绍了Linux中几种延时函数sleep、usleep、nanosleep、select和pselect的使用和区别。它们分别以秒、微秒和纳秒为单位提供暂停功能。在精确度对比中，usleep和nanosleep在低精度场景下表现接近，而在高精度场景下，所有函数表现相当。注意使用这些函数时要处理可能的信号中断。文章提供了测试代码供参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、简介

sleep()-------以秒为单位
#include<unistd.h>
unsigned int sleep(unsigned int seconds);
return：若进程暂停到参数seconds 所指定的时间，成功则返回0，若有信号中断则返回剩余秒数。
在linux中，sleep是通过nanosleep实现的。在一些其他系统中（例如POSIX.1），它是通过alarm()来实现的。

usleep()----以微秒为单位
#include<unistd.h>
unsigned int usleep(unsigned int useconds);
return：若进程暂停到参数seconds 所指定的时间，成功则返回0，若有信号中断则返回剩余微秒数。

nanosleep( )---------以纳秒为单位
#include<time.h>
struct timespec
{
time_t tv_sec; /* 秒seconds /
long tv_nsec; / 纳秒nanoseconds */
};
int nanosleep(const struct timespec req, struct timespec rem);
return: 若进程暂停到参数req所指定的时间，成功则返回0，若有信号中断则返回-1，并且将剩余微秒数记录在rem中。
req->tv_sec是以秒为单位，而tv_nsec以毫微秒为单位（10的-9次方秒）。
由于调用nanosleep是是进程进入TASK_INTERRUPTIBLE,这种状态是会相应信号而进入TASK_RUNNING状态的。

2、注意

使用这些函数时一定要注意判断返回值。有时候会出现sleep函数被系统中断的情况，导致结果不符合预期。
while (nanosleep(&ts, &ts) == -1 && errno == EINTR) {}

3、精确度对比

低精度情况（100000us及以上）：usleep和nanosleep表现差不多。select和pselect表现较差。
高精度情况（100000us及以上）：四者表现差不多。
fuction time(usec) realtime reduce

----------------------------------------------------
        usleep         500000     500091         91
        nanosleep      500000     500089         89
        select         500000     500540        540
        pselect        500000     500549        549
--------------------------------
        usleep         100000     100078         78
        nanosleep      100000     100110        110
        select         100000     100157        157
        pselect        100000     100149        149
--------------------------------
        usleep          50000      50091         91
        nanosleep       50000      50107        107
        select          50000      50111        111
        pselect         50000      50084         84
--------------------------------
        usleep          10000      10086         86
        nanosleep       10000      10091         91
        select          10000      10089         89
        pselect         10000      10088         88
--------------------------------
        usleep           1000       1089         89
        nanosleep        1000       1065         65
        select           1000       1065         65
        pselect          1000       1066         66
--------------------------------
        usleep            900        969         69
        nanosleep         900        974         74
        select            900        970         70
        pselect           900        980         80
--------------------------------
        usleep            500        569         69
        nanosleep         500        565         65
        select            500        569         69
        pselect           500        569         69
--------------------------------
        usleep            100        166         66
        nanosleep         100        165         65
        select            100        163         63
        pselect           100        163         63
--------------------------------
        usleep             10         73         63
        nanosleep          10         76         66
        select             10         73         63
        pselect            10         78         68
--------------------------------
        usleep              1         64         63
        nanosleep           1         66         65
        select              1         65         64
        pselect             1         63         62
--------------------------------
4、测试代码
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<sys/time.h>
#include<errno.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/select.h>
 
 
int main(int argc, char **argv)
{
    unsigned int nTimeTestSec = 0;
    unsigned int nTimeTest = 0;
    struct timeval tvBegin;
    struct timeval tvNow;
    int ret = 0;
    unsigned int nDelay = 0;
    struct timeval tv;
    int fd = 1;
    int i = 0;
    struct timespec req;
 
    unsigned int delay[20] = 
        {500000, 100000, 50000, 10000, 1000, 900, 500, 100, 10, 1, 0};
    int nReduce = 0; //误差
 
    fprintf(stderr, "%19s%12s%12s%12s\n", "fuction", "time(usec)", "realtime", "reduce");
    fprintf(stderr, "----------------------------------------------------\n");
    for (i = 0; i < 20; i++)
    {
        if (delay[i] <= 0)
            break;
        nDelay = delay[i];
        //test sleep
        gettimeofday(&tvBegin, NULL);
        ret = usleep(nDelay);
        if(ret == -1)
        {
            fprintf(stderr, "usleep error, errno=%d [%s]\n", errno, strerror(errno));
        }
        gettimeofday(&tvNow, NULL);
        nTimeTest = (tvNow.tv_sec - tvBegin.tv_sec) * 1000000 + tvNow.tv_usec - tvBegin.tv_usec;
        nReduce = nTimeTest - nDelay;
 
         fprintf (stderr, "\t usleep       %8u   %8u   %8d\n", nDelay, nTimeTest,nReduce);
 
         //test nanosleep
         req.tv_sec = nDelay/1000000;
         req.tv_nsec = (nDelay%1000000) * 1000;
 
         gettimeofday(&tvBegin, NULL);
         ret = nanosleep(&req, NULL);
         if (-1 == ret)
         {
            fprintf (stderr, "\t nanousleep   %8u   not support\n", nDelay);
         }
         gettimeofday(&tvNow, NULL);
         nTimeTest = (tvNow.tv_sec - tvBegin.tv_sec) * 1000000 + tvNow.tv_usec - tvBegin.tv_usec;
         nReduce = nTimeTest - nDelay;
         fprintf (stderr, "\t nanosleep    %8u   %8u   %8d\n", nDelay, nTimeTest,nReduce);
 
         //test select
         tv.tv_sec = 0;
         tv.tv_usec = nDelay;
 
         gettimeofday(&tvBegin, NULL);
         ret = select(0, NULL, NULL, NULL, &tv);
         if (-1 == ret)
         {
            fprintf(stderr, "select error. errno = %d [%s]\n", errno, strerror(errno));
         }
 
         gettimeofday(&tvNow, NULL);
         nTimeTest = (tvNow.tv_sec - tvBegin.tv_sec) * 1000000 + tvNow.tv_usec - tvBegin.tv_usec;
         nReduce = nTimeTest - nDelay;
         fprintf (stderr, "\t select       %8u   %8u   %8d\n", nDelay, nTimeTest,nReduce);
 
         //pselcet
         req.tv_sec = nDelay/1000000;
         req.tv_nsec = (nDelay%1000000) * 1000;
 
         gettimeofday(&tvBegin, NULL);
         ret = pselect(0, NULL, NULL, NULL, &req, NULL);
         if (-1 == ret)
         {
            fprintf(stderr, "select error. errno = %d [%s]\n", errno, strerror(errno));
         }
 
         gettimeofday(&tvNow, NULL);
         nTimeTest = (tvNow.tv_sec - tvBegin.tv_sec) * 1000000 + tvNow.tv_usec - tvBegin.tv_usec;
         nReduce = nTimeTest - nDelay;
         fprintf (stderr, "\t pselect      %8u   %8u   %8d\n", nDelay, nTimeTest,nReduce);
 
         fprintf (stderr, "--------------------------------\n");
 
    }
    
    return 0;
}

参考博客：https://www.jianshu.com/p/42abcc2c9e50

【驱动】TI AM437x(内核调试-08)：测试usleep、sleep函数精度，配置高精度定时器
郭老二
02-21 236
测试usleep、sleep函数精度，配置高精度定时器
嵌入式Linux系统编程 — 5.5 sleep、usleep和nanosleep系统休眠函数
几度春风里的博客
07-01 1653
在高负载或密集计算任务中，程序可能需要定期休眠，以避免长时间占用CPU，给系统其他部分留出处理时间。：在遇到错误或异常时，程序可能会选择休眠一段时间，然后重试操作，这可以作为简单的错误恢复机制。有时需要将进程暂停或休眠一段时间， 进入休眠状态之后，程序将暂停运行，直到休眠结束。：在某些嵌入式系统或移动设备上，休眠可以用于节能，通过减少CPU的活动来降低功耗。：在需要执行定时任务的场景中，休眠可以用于实现简单的时间调度。usleep函数使调用进程休眠指定的微秒数。sleep函数使调用进程休眠指定的秒数。
linux多线程编程，替代sleep的几种方式
热门推荐
horst Hu的专栏
08-27 3万+
我只想要进程的某个线程休眠一段时间的，可是用sleep()是将整个进程都休眠的，这个可能就达不到，我们想要的效果了。 目前我知道有三种方式： 1 usleep    这个是轻量级的， 听说能可一实现线程休眠， 我个人并不喜欢这种方式，所以我没有验证它的可行信（个人不推荐）。 2 select    这个可以，我也用过这种方式， 它是在轮询。 3  pthread_cond_timedwa
usleep函数
vivohan的专栏
06-02 2734
usleep功能把进程挂起一段时间， 单位是微秒（百万分之一秒）； 头文件： unistd.h 语法: void usleep(int micro_seconds); 返回值: 无 内容说明：本函数可暂时使程序停止执行。参数 micro_seconds 为要暂停的微秒数(us)。 注意： 这个函数不能工作在windows 操作系统中。用在Linux的测试环境下面。 参见：usle
【Linux C/C++ 延时(延迟)函数比较】介绍Linux系统中常用的延时函数sleep、usleep、nanosleep、select和std::sleep_for()的区别和使用场景
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-11 1万+
延时函数，sleep、usleep、nanosleep、select比较
PHP sleep() 函数, usleep() 函数
盐碘
01-10 3318
PHP sleep() 函数 定义和用法 sleep() 函数延迟代码执行若干秒。 语法sleep(seconds) seconds 必需。以秒计的暂停时间。 返回值 若成功，返回 0，否则返回 false。 错误／异常 如果指定的描述 seconds 是负数，该函数将生成一个 E_WARNING。 例子"; //暂停 10 秒 sleep(10)
linux的sleep()和usleep()的使用和区别
北雨南萍
03-08 5011
函数名: sleep 头文件: #include // 在VC中使用带上头文件         #include  // 在gcc编译器中，使用的头文件因gcc版本的不同而不同 功  能: 执行挂起指定的秒数 语  法: unsigned sleep(unsigned seconds); 示例: #include #include int main() {   i
Linux使用sleep实现进程睡眠/延时/暂停（shell有sleep/usleep命令，函数调用有nanosleep）
reading-conference-writing
09-29 8193
一般Shell中都会使用sleep进行延时。但sleep有很多种用法，并且shell还有usleep，函数调用还有nanosleep，他们的作用又和Sleep有些区别，这里一一介绍
linux usleep 函数,Linux 高精確的時序（sleep， usleep，nanosleep）
weixin_32389427的博客
05-04 1438
首先, 我会说不保证你在使用者模式 (user-mode) 中执行的行程(process) 能够精确地控制时序因为 Linux 是个多工的作业环境. 你在执行中的行程 (process)随时会因为各种原因被暂停大约 10 毫秒到数秒 (在系统负荷非常高的时候). 然而, 对於大多数使用 I/O 埠的应用而言,这个延迟时间实际上算不了什麽. 要缩短延迟时间, 你得使用函式 nice 将你在执行中的行...
C++ sleep相关延时函数
Han同学
04-07 2944
C++ sleep相关延时函数
usleep() 函数
冷月醉雪的博客
03-31 6793
查看更多 https://www.yuque.com/docs/share/24e68431-0952-4349-87f1-454a3fc61a18
Linux 延时函数 nanosleep、select比较
2004v2004的专栏
02-20 669
Linux c语言 延时 函数 nanosleep、select 使用
关于select定时器和usleep定时器的准确率说明
w87510255的专栏
06-14 1344
。。。。。。     unsigned int nSec= 0;     unsigned int nUSec= 0;     struct timeval tvBegin, tvNow;     int delay[20] = {500000,100000,50000,10000,1000,900,500,100,10,1,0};     int nReaduce = 0;    
Linux(入门基础):18---Linux下sleep函数与usleep函数
du_lijun的博客
11-24 3125
时钟换算： 1s = 1000ms 1ms = 1000μs 1μs = 1000ns 1ns = 1000ps 一、sleep 头文件: #include <unistd.h> 功 能: 执行挂起指定的秒数 语 法: unsigned sleep(unsigned seconds); 举例： void father() { int i; for(i = 0 ;i < 3;i++) { printf("father\n"); sleep(1); } }.
sleep usleep select 延时比较
03-30 1万+
 再论精确延时(usleep,nanosleep,select)/*        make:  gcc -o test_sleep test_sleep.c *//*        #include  "comm_main.h" */#include ;#include ;#include ;#include ;#include ;#include ;#include ;#include ;
关于短延迟 SLEEP USLEEP NANOSLEEP SELECT
积累与分享
11-11 1061
<br />udelay(unsigned long usecs);mdelay(unsigned long msecs);<br /><br />前者用软件循环指定的微妙数，后者调用前者达到延迟毫秒级。udelay 函数只能用于获取较短的时间延迟，因为loops_per_second值的精度只有8位，所以，当计算更长的延迟时会积累出相当大的误差。尽管最大能允许的延迟将近1秒(因为更长的延迟就要溢出)，推荐的 udelay 函数的参数的最大值是取1000微秒(1毫秒)。延迟大于 11 毫秒时可以使用函数 m
Linux高精确的时序（sleep， usleep，nanosleep）
程序狗的成长之路
11-30 8336
方式一、　（sleep， usleep，nanosleep）本质上都是系统调用，但是精确程度不一样，依次递增。 方式二、nice函数 功能描述 改变进程优先级，也就是改变进程执行的优先顺序。 函数定义 int nice(int inc); 返回值 成功执行时，返回新的nice值。失败返回-1 参数介绍 inc数值越大则优先级越低（进程执行慢），超级用户可以使用负的inc
linux下使用select实现精确定时器
weixin_34184561的博客
11-02 541
在编写程序时，我们经常回用到定时器。本文讲述如何使用select实现超级时钟。使用select函数，我们能实现微妙级别精度的定时器。同时，select函数也是我们在编写非阻塞程序时经常用到的一个函数。 首先看看select函数原型如下： int select(int nfds, fd_set *readfds, fd_set *writefds, fd...
linux延时函数
最新发布
07-06
### Linux 延时函数的使用方法 在Linux系统中，延时函数可以分为 **用户空间延时函数** 和 **内核空间延时函数** 两种类型。不同的场景下应选择合适的延时函数以满足时间精度和资源占用的需求。 #### 用户空间延时函数 适用于应用程序开发，主要包含以下几种： 1. `sleep(unsigned int seconds)` - 功能：使进程休眠指定的秒数。 - 精度：秒级。 - 示例： ```c sleep(2); // 延时2秒 ``` 2. `usleep(unsigned long usec)` - 功能：使进程休眠指定的微秒数。 - 精度：微秒级（1秒=1,000,000微秒）。 - 示例： ```c usleep(1000000); // 延时1秒 ``` 3. `nanosleep(const struct timespec *req, struct timespec *rem)` - 功能：提供纳秒级别的高精度延时。 - 精度：纳秒级（1秒=1,000,000,000纳秒）。 - 示例： ```c struct timespec ts = {1, 500000000}; // 1秒500,000,000纳秒 nanosleep(&ts, NULL); ``` 4. `select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)` - 功能：通过设置超时参数实现延时。 - 精度：微秒级。 - 示例： ```c struct timeval tv = {2, 0}; // 2秒 select(0, NULL, NULL, NULL, &tv); ``` 5. `pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask)` - 功能：类似于`select`，但支持更精确的超时控制（纳秒级）。 - 精度：纳秒级。 - 示例： ```c struct timespec ts = {1, 500000000}; // 1秒500,000,000纳秒 pselect(0, NULL, NULL, NULL, &ts, NULL); ``` #### 内核空间延时函数 适用于编写设备驱动程序或内核模块，主要包括以下几种： 1. `ndelay(unsigned long nsecs)` - 功能：纳秒级别的忙等待延时。 - 精度：纳秒级。 - 适用范围：短时间延时（通常小于几纳秒）。 - 示例： ```c ndelay(100); // 延时100纳秒 ``` 2. `udelay(unsigned long usecs)` - 功能：微秒级别的忙等待延时。 - 精度：微秒级。 - 适用范围：短时间延时（通常小于200微秒）。 - 示例： ```c udelay(100); // 延时100微秒 ``` 3. `mdelay(unsigned long msecs)` - 功能：毫秒级别的忙等待延时。 - 精度：毫秒级。 - 适用范围：较长时间延时（通常大于200微秒）。 - 示例： ```c mdelay(100); // 延时100毫秒 ``` 4. `ssleep(unsigned int seconds)` - 功能：秒级别的睡眠延时。 - 精度：秒级。 - 优点：不占用CPU资源。 - 缺点：时间精度较低。 - 示例： ```c ssleep(2); // 延时2秒 ``` 5. `msleep(unsigned int msecs)` - 功能：毫秒级别的睡眠延时。 - 精度：毫秒级。 - 优点：不占用CPU资源。 - 缺点：时间精度较低。 - 示例： ```c msleep(100); // 延时100毫秒 ``` #### 使用建议 - **对于高精度要求**：优先使用`nanosleep`或内核中的`ndelay`、`udelay`等函数。 - **对于低精度要求**：使用`sleep`、`usleep`、`ssleep`、`msleep`等函数。 - **避免长时间忙等待**：忙等待会消耗大量CPU资源，适合短时间延时；长延时应使用睡眠函数[^1]。 ### 示例代码 ```c #include <stdio.h> #include <unistd.h> int main(void) { int i = 10; while (i--) { sleep(2); // 延时2秒 printf("Sleep 2s!\n"); usleep(1000000); // 延时1秒 printf("Sleep 1000000us!\n"); } return 0; } ``` ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值