精华内容
下载资源
问答
  • c# 延时 不占用cpu,窗口卡死,影响其它代码执行
    千次阅读
    2018-05-05 23:40:12

    实现方法是通过使用计时器,等待消息抵达,在等待过程中转让windows权限,可以达到延时目的(参考了其他例程),而且不影响窗口卡死。

    这个引用需要手动导入,如果不需要考虑窗口卡死,可以去掉,不影响延时效果

    System.Windows.Forms
    using System;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;
    
    namespace ConsoleApp2
    {
        public class Timer
        {
            public delegate void TimerCompleteDelegate();
    
            [DllImport("kernel32.dll")]
            static extern IntPtr CreateWaitableTimer(IntPtr lpTimerAttributes, bool bManualReset, string lpTimerName);
    
            [DllImport("kernel32.dll")]
            static extern bool SetWaitableTimer(IntPtr hTimer, [In] ref long ft, int lPeriod, TimerCompleteDelegate pfnCompletionRoutine, IntPtr pArgToCompletionRoutine, bool fResume);
    
            [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto)]
            [return: MarshalAs(UnmanagedType.Bool)]
            static extern bool CloseHandle(IntPtr hObject);
    
            [DllImport("User32.dll")]
            static extern int MsgWaitForMultipleObjects(int nCount, ref IntPtr handle, bool fWaitAll, int dwMilliseconds, int dwWakeMask);
    
    
            /// <summary>
            /// 不占用cpu,窗口不卡死,不影响其它代码执行
            /// </summary>
            /// <param name="time">单位毫秒</param>
            public static bool Sleep(int time)
            {
                TimerCompleteDelegate TimerComplete = new TimerCompleteDelegate(TimerCompleted);
                long Interval = -10 * time * 1000;//占8字节
                //创建计时器
                IntPtr handle = CreateWaitableTimer(IntPtr.Zero, true, "WaitableTimer");
                SetWaitableTimer(handle, ref Interval, 0, TimerComplete, IntPtr.Zero, true);
                //等待消息抵达
                while (MsgWaitForMultipleObjects(1, ref handle, false, -1, 255) != 0)
                {
                    //转让权限
                    Application.DoEvents();
                }
                return CloseHandle(handle);
            }
            private static void TimerCompleted()
            {
                // 一旦定时器过期,就执行例程。这是独立于调用OnTimeRebug事件的类实现的程序执行的。
            }
        }
    }
    
    如果对调用SetWaitableTimer不是特别清楚的,可以点击 传送门
    更多相关内容
  • qt延时延时方法及cpu占用问题

    千次阅读 2019-01-01 16:30:09
    qt的延时方法一般有以下3种: ...1、精度低,卡界面,CPU占用少 Qt为我们提供了几个可以用于线程Sleep的函数,分别是: void QThread::sleep ( unsigned long secs ) [static protected] ...

    参考资料:https://blog.csdn.net/tingsking18/article/details/5304254

    qt的延时方法一般有以下3种:

    1、精度低,卡界面,CPU占用少

    Qt为我们提供了几个可以用于线程Sleep的函数,分别是:
        void QThread::sleep ( unsigned long secs )   [static protected] 
        void QThread::msleep ( unsigned long msecs )   [static protected]
        void QThread::usleep ( unsigned long usecs )   [static protected]
    sleep的单位分别是秒、毫秒、微秒
    
    如:QThread::msleep(100); 
    
    • sleep函数是使调用sleep函数的线程休眠,线程主动放弃时间片。当经过指定的时间间隔后,再启动线程,继续执行代码。
    • 在一些多线程中可能会看到sleep(0),其主要目的是让出时间片。
    • sleep函数的精度非常低,当系统越繁忙的时候它精度也就越低,有时候我们休眠1秒,可能3秒后才能继续执行。它的精度取决于线程自身优先级、其他线程的优先级,以及线程的数量等因素,所以说sleep函数是不能用来精确计时的。

     

    2、使用时间轮询查看,不卡界面,但是 cpu 占用率高,起码50%以上

    自定义的非阻塞延时函数:

    void MySleep(unsigned int msec)
    {
        QTime delayTime = QTime::currentTime().addMSecs(msec);
        while(QTime::currentTime() <delayTime )
        {
            QCoreApplication::processEvents(QEventLoop::AllEvents,100);
        }
    }

     

    processEvents会让Qt继续处理线程所在的消息队列中未处理的消息,直到消息队列中没有消息可以处理,当进行长时间的操作的时候可以调用此函数(比方说拷贝文件)。

    3、和2类似,当然还有很多类似的方法来做延时,但是通常这样做精度高了,然而CPU实在受不了

    void mySleep(unsigned int msec)
    {
        QTimer t; 
        t.start();
        while(t.elapsed() <msec)
        { 
            QCoreApplication::processEvents(); 
        }
    } 

    总的来说,延时的使用还是看情况吧,如过你在 while里面需要延时,而且精度要求不是很高(个人觉得10ms界限吧),还是使用方法1吧,不然CPU被占的死死的!

    最好是两种方式结合:

    void MySleep(unsigned int msec)
    {
        QTime delayTime = QTime::currentTime().addMSecs(msec);
        while(QTime::currentTime() < delayTime )
        {
            QCoreApplication::processEvents(QEventLoop::AllEvents,100);
            QThread::msleep(100); 
        }
    }

    这样就达到来中和的效果了

     

    关于此部分的一些知识点梳理:

    (1)wait和sleep的比较

    sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后,线程不一定立即恢复执行。这是因为在那个时刻,其它线程可能正在运行而且没有被调度为放弃执行,除非
            (a)“醒来”的线程具有更高的优先级。
            (b)正在运行的线程因为其它原因而阻塞。
    wait()会使调用它的线程暂停执行,被调对象进入等待状态,直到被唤醒或等待时间到。

     

     

     

     

     

     

    展开全文
  • VB实现不占用CPU延时

    千次阅读 2013-12-25 01:31:02
    mobjWaitTimer.Wait (5000) ' 延时5秒 自行更改 End If Loop Until Not mbStop Set mobjWaitTimer = Nothing End Sub Private Sub Command1_Click() RunProcess Print "有没有延时...
    窗体:


    Private mobjWaitTimer As clsWaitableTimer
    Dim mbWorkToDo As Boolean
    Dim mbStop As Boolean
    Private Sub RunProcess()


    Set mobjWaitTimer = New clsWaitableTimer


    Do


    If mbWorkToDo Then
    'Call ProcessWork
    Else
    mobjWaitTimer.Wait (5000) ' 延时5秒 自行更改
    End If


    Loop Until Not mbStop


    Set mobjWaitTimer = Nothing
    End Sub


    Private Sub Command1_Click()
    RunProcess
    Print "有没有延时成功呢?"
    RunProcess
    Print "应该有吧"
    End Sub
     


    类模块:

    Option Explicit


    Private Type FILETIME
    dwLowDateTime As Long
    dwHighDateTime As Long
    End Type
    Private Const WAIT_ABANDONED& = &H80&
    Private Const WAIT_ABANDONED_0& = &H80&
    Private Const WAIT_FAILED& = -1&
    Private Const WAIT_IO_COMPLETION& = &HC0&
    Private Const WAIT_OBJECT_0& = 0
    Private Const WAIT_OBJECT_1& = 1
    Private Const WAIT_TIMEOUT& = &H102&
    Private Const INFINITE = &HFFFF
    Private Const ERROR_ALREADY_EXISTS = 183&
    Private Const QS_HOTKEY& = &H80
    Private Const QS_KEY& = &H1
    Private Const QS_MOUSEBUTTON& = &H4
    Private Const QS_MOUSEMOVE& = &H2
    Private Const QS_PAINT& = &H20
    Private Const QS_POSTMESSAGE& = &H8
    Private Const QS_SENDMESSAGE& = &H40
    Private Const QS_TIMER& = &H10
    Private Const QS_MOUSE& = (QS_MOUSEMOVE Or QS_MOUSEBUTTON)
    Private Const QS_INPUT& = (QS_MOUSE Or QS_KEY)
    Private Const QS_ALLEVENTS& = (QS_INPUT Or QS_POSTMESSAGE Or QS_TIMER Or QS_PAINT Or QS_HOTKEY)
    Private Const QS_ALLINPUT& = (QS_SENDMESSAGE Or QS_PAINT Or QS_TIMER Or QS_POSTMESSAGE Or QS_MOUSEBUTTON Or QS_MOUSEMOVE Or QS_HOTKEY Or QS_KEY)
    Private Const UNITS = 4294967296#
    Private Const MAX_LONG = -2147483648#
    Private Declare Function CreateWaitableTimer _
    Lib "kernel32" _
    Alias "CreateWaitableTimerA" (ByVal lpSemaphoreAttributes As Long, _
    ByVal bManualReset As Long, _
    ByVal lpName As String) As Long


    Private Declare Function OpenWaitableTimer _
    Lib "kernel32" _
    Alias "OpenWaitableTimerA" (ByVal dwDesiredAccess As Long, _
    ByVal bInheritHandle As Long, _
    ByVal lpName As String) As Long


    Private Declare Function SetWaitableTimer _
    Lib "kernel32" (ByVal hTimer As Long, _
    lpDueTime As FILETIME, _
    ByVal lPeriod As Long, _
    ByVal pfnCompletionRoutine As Long, _
    ByVal lpArgToCompletionRoutine As Long, _
    ByVal fResume As Long) As Long


    Private Declare Function CancelWaitableTimer Lib "kernel32" (ByVal hTimer As Long)


    Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long


    Private Declare Function WaitForSingleObject _
    Lib "kernel32" (ByVal hHandle As Long, _
    ByVal dwMilliseconds As Long) As Long


    Private Declare Function MsgWaitForMultipleObjects _
    Lib "user32" (ByVal nCount As Long, _
    pHandles As Long, _
    ByVal fWaitAll As Long, _
    ByVal dwMilliseconds As Long, _
    ByVal dwWakeMask As Long) As Long


    Private mlTimer As Long


    Private Sub Class_Terminate()
    On Error Resume Next
    If mlTimer <> 0 Then CloseHandle mlTimer
    End Sub


    Public Sub Wait(MilliSeconds As Long)
    On Error GoTo ErrHandler
    Dim ft As FILETIME
    Dim lBusy As Long
    Dim lRet As Long
    Dim dblDelay As Double
    Dim dblDelayLow As Double
    mlTimer = CreateWaitableTimer(0, True, App.EXEName & "Timer" & Format$(Now(), "NNSS"))
    If Err.LastDllError <> ERROR_ALREADY_EXISTS Then
    ft.dwLowDateTime = -1
    ft.dwHighDateTime = -1
    lRet = SetWaitableTimer(mlTimer, ft, 0, 0, 0, 0)
    End If
    dblDelay = CDbl(MilliSeconds) * 10000#
    ft.dwHighDateTime = -CLng(dblDelay / UNITS) - 1
    dblDelayLow = -UNITS * (dblDelay / UNITS - Fix(CStr(dblDelay / UNITS)))
    If dblDelayLow < MAX_LONG Then dblDelayLow = UNITS + dblDelayLow
    ft.dwLowDateTime = CLng(dblDelayLow)
    lRet = SetWaitableTimer(mlTimer, ft, 0, 0, 0, False)
    Do
    lBusy = MsgWaitForMultipleObjects(1, mlTimer, False, INFINITE, QS_ALLINPUT&)
    DoEvents
    Loop Until lBusy = WAIT_OBJECT_0
    CloseHandle mlTimer
    mlTimer = 0
    Exit Sub
    ErrHandler:
    Err.Raise Err.Number, Err.Source, "[clsWaitableTimer.Wait]" & Err.Description
    End Sub


    展开全文
  • ' 利用线程解决“延时()”卡死程序的问题。此方法受“超级大BUG”启发。 易语言完美延时模块源码例程程序结合易语言多线程支持库,调用API函数实现完美延时...完美延时()卡死、低cpu。缺点:未知。 三叶自学编程网
  • 高精度延时,cpu占用低,窗口卡死,一次最大可延时几年 (无返回值) 易语言源码下载
  • 单片机实现延时两种方法

    千次阅读 2020-09-08 14:26:33
    实现延时通常有两种方法:一种是硬件延时,要用到定时器/计数器,这种方法可以提高CPU的工作效率,也能做到精确延时;另一种是软件延时,这种方法主要采用循环体进行。 ▍1 、使用定时器/计数器实现精确延时 ...

    实现延时通常有两种方法:一种是硬件延时,要用到定时器/计数器,这种方法可以提高CPU的工作效率,也能做到精确延时;另一种是软件延时,这种方法主要采用循环体进行。

     

    ▍1 、使用定时器/计数器实现精确延时

     

    单片机系统一般常选用11.059 2 MHz、12 MHz或6 MHz晶振。第一种更容易产生各种标准的波特率,后两种的一个机器周期分别为1 μs和2 μs,便于精确延时。本程序中假设使用频率为12 MHz的晶振。最长的延时时间可达216=65 536 μs。若定时器工作在方式2,则可实现极短时间的精确延时;如使用其他定时方式,则要考虑重装定时初值的时间(重装定时器初值占用2个机器周期)。

    在实际应用中,定时常采用中断方式,如进行适当的循环可实现几秒甚至更长时间的延时。使用定时器/计数器延时从程序的执行效率和稳定性两方面考虑都是最佳的方案。但应该注意,C51编写的中断服务程序编译后会自动加上PUSH ACC、PUSH PSW、POP PSW和POP ACC语句,执行时占用了4个机器周期;如程序中还有计数值加1语句,则又会占用1个机器周期。这些语句所消耗的时间在计算定时初值时要考虑进去,从初值中减去以达到最小误差的目的。

     

    2 、软件延时与时间计算

     


    在很多情况下,定时器/计数器经常被用作其他用途,这时候就只能用软件方法延时。下面介绍几种软件延时的方法。
    2.1 短暂延时
    可以在C文件中通过使用带_NOP_( )语句的函数实现,定义一系列不同的延时函数,如Delay10us( )、Delay25us( )、Delay40us( )等存放在一个自定义的C文件中,需要时在主程序中直接调用。如延时10 μs的延时函数可编写如下:

    1.  
    2. void Delay10us() {
    3. _NOP_( );
    4. _NOP_( );
    5. _NOP_( );
    6. _NOP_( );
    7. _NOP_( );
    8. _NOP_( );
    9. }
    复制代码
     

    Delay10us( )函数中共用了6个_NOP_( )语句,每个语句执行时间为1 μs。主函数调用Delay10us( )时,先执行一个LCALL指令(2 μs),然后执行6个_NOP_( )语句(6 μs),最后执行了一个RET指令(2 μs),所以执行上述函数时共需要10 μs。  

    可以把这一函数当作基本延时函数,在其他函数中调用,即嵌套调用[4],以实现较长时间的延时;但需要注意,如在Delay40us( )中直接调用4次Delay10us( )函数,得到的延时时间将是42 μs,而不是40 μs。这是因为执行Delay40us( )时,先执行了一次LCALL指令(2 μs),然后开始执行第一个Delay10us( ),执行完最后一个Delay10us( )时,直接返回到主程序。依此类推,如果是两层嵌套调用,如在Delay80us( )中两次调用Delay40us( ),则也要先执行一次LCALL指令(2 μs),然后执行两次Delay40us( )函数(84 μs),所以,实际延时时间为86 μs。简言之,只有最内层的函数执行RET指令。该指令直接返回到上级函数或主函数。如在Delay80μs( )中直接调用8次Delay10us( ),此时的延时时间为82 μs。通过修改基本延时函数和适当的组合调用,上述方法可以实现不同时间的延时。

    2.2 在C51中嵌套汇编程序段实现延时
    在C51中通过预处理指令#pragma asm和#pragma endasm可以嵌套汇编语言语句。用户编写的汇编语言紧跟在#pragma asm之后,在#pragma endasm之前结束。
    如:

    #pragma asm
    汇编语言程序段#pragma endasm
    延时函数可设置入口参数,可将参数定义为unsigned char、int或long型。根据参数与返回值的传递规则,这时参数和函数返回值位于R7、R7R6、R7R6R5中。在应用时应注意以下几点:
    ◆ #pragma asm、#pragma endasm不允许嵌套使用;◆ 在程序的开头应加上预处理指令#pragma asm,在该指令之前只能有注释或其他预处理指令;◆ 当使用asm语句时,编译系统并不输出目标模块,而只输出汇编源文件;◆ asm只能用小写字母,如果把asm写成大写,编译系统就把它作为普通变量;◆ #pragma asm、#pragma endasm和 asm只能在函数内使用。

     

    将汇编语言与C51结合起来,充分发挥各自的优势,无疑是单片机开发人员的最佳选择。
    2.3 使用示波器确定延时时间
    利用示波器来测定延时程序执行时间。方法如下:编写一个实现延时的函数,在该函数的开始置某个I/O口线如P1.0为高电平,在函数的最后清P1.0为低电平。在主程序中循环调用该延时函数,通过示波器测量P1.0引脚上的高电平时间即可确定延时函数的执行时间。方法如下:

    1.  
    2. sbit T_point = P1^0;
    3. void Dly1ms(void) {
    4. unsigned int i,j;
    5. while (1) {
    6. T_point = 1;
    7. for(i=0;i<2;i++){
    8. for(j=0;j<124;j++){;}
    9. }
    10. T_point = 0;
    11. for(i=0;i<1;i++){
    12. for(j=0;j<124;j++){;}
    13. }
    14. }
    15. }
    16. void main (void) {
    17. Dly1ms();
    18. }
    复制代码


    把P1.0接入示波器,运行上面的程序,可以看到P1.0输出的波形为周期是3 ms的方波。其中,高电平为2 ms,低电平为1 ms,即for循环结构“for(j=0;j<124;j++) {;}”的执行时间为1 ms。通过改变循环次数,可得到不同时间的延时。当然,也可以不用for循环而用别的语句实现延时。这里讨论的只是确定延时的方法。

    2.4 使用反汇编工具计算延时时间
    用Keil C51中的反汇编工具计算延时时间,在反汇编窗口中可用源程序和汇编程序的混合代码或汇编代码显示目标应用程序。为了说明这种方法,还使用

    1.  
    2. for (i=0;i
    3. C:0x000FE4CLRA//1T
    4. C:0x0010FEMOVR6,A//1T
    5. C:0x0011EEMOVA,R6//1T
    6. C:0x0012C3CLRC//1T
    7. C:0x00139FSUBBA,DlyT //1T
    8. C:0x00145003JNCC:0019//2T
    9. C:0x00160E INCR6//1T
    10. C:0x001780F8SJMPC:0011//2T
    复制代码


    可以看出,0x000F~0x0017一共8条语句,分析语句可以发现并不是每条语句都执行DlyT次。核心循环只有0x0011~0x0017共6条语句,总共8个机器周期,第1次循环先执行“CLR A”和“MOV R6,A”两条语句,需要2个机器周期,每循环1次需要8个机器周期,但最后1次循环需要5个机器周期。DlyT次核心循环语句消耗(2+DlyT×8+5)个机器周期,当系统采用12 MHz时,精度为7 μs。
    当采用while (DlyT--)循环体时,DlyT的值存放在R7中。相对应的汇编代码如下:

    1.  
    2. C:0x000FAE07MOVR6, R7//1T
    3. C:0x00111F DECR7//1T
    4. C:0x0012EE MOVA,R6//1T
    5. C:0x001370FAJNZC:000F//2T
    复制代码
     

    循环语句执行的时间为(DlyT+1)×5个机器周期,即这种循环结构的延时精度为5 μs。
    通过实验发现,如将while (DlyT--)改为while (--DlyT),经过反汇编后得到如下代码:

    • C:0x0014DFFE DJNZR7,C:0014//2T

    可以看出,这时代码只有1句,共占用2个机器周期,精度达到2 μs,循环体耗时DlyT×2个机器周期;但这时应该注意,DlyT初始值不能为0。
    注意:计算时间时还应加上函数调用和函数返回各2个机器周期时间。
    第二篇

    声明:作者初学单片机编程,本着刨根问底的探索精神,对延时代码进行了完全透彻的分析,计算出其中的误差,根据不同代码占用机器周期进行调整。至于调整0.01ms左右的时间误差对实际应用有何实际意义则不敢妄谈。不过您看完这篇文章的绿色部分,即可明确延时程序的设计方法。
    举例程序段落:
    系统频率:6MHz

    1.  
    2. Delay: MOV R5,#25 ;5ms延时——MOV指令占用1机器周期时间
    3. Delay1: MOV R6,#200 ;200ms延时
    4. Delay2: MOV R7,#166 ;1ms延时常数
    5. Delay3: NOP ;空指令,什么都不做,停留1机器周期时间
    6. DJNZ R7,Delay3 ;R7减1赋值给R7,如果此时R7不等于零,转到Delay3执行。——2机器周期时间
    7. DJNZ R6,Delay2
    8. DJNZ R5,Delay1
    复制代码


    解析如下:
    1、首先计算机器周期T=12*1/f=2μs。
    2、注意DJNZ R7,Delay3每执行1次需要占用NOP的时间和DJNZ本身的时间共3个机器周期。6μs。那么1ms的时间需要1ms*1000/6μs=166.67,取166。
    3、注意DJNZ R6,Delay2是在166次循环后执行1次的(时间为MOV机器周期+本身机器周期,3*2=6μs),直到166*200次后,R6=0,才执行DJNZ R5,Delay1。
    4、DJNZ R5,Delay1是在R5不为0的时候循环回去。时间也为6μs。
    5、时间总计:166*200*25*6μs+200*25*6μs+25*6μs=5010150μs,合计5.01015ms(编程的人都遇到过类似的潜逃循环,此程序忽略了执行MOV的时间,只计算了循环所用时间,即166*200*25*6/1000000=4.98ms,近似5ms)。

     

    程序改进:
    去掉NOP命令,整数化1ms需要的延时常数。

    1.  
    2. Delay: MOV R5,#25 ;5ms延时——MOV指令占用1机器周期时间
    3. Delay1: MOV R6,#200 ;200ms延时
    4. Delay2: MOV R7,#250 ;1ms延时常数
    5. Delay3: ;NOP ;空指令,什么都不做,停留1机器周期时间
    6. DJNZ R7,Delay3 ;R7减1赋值给R7,如果此时R7不等于零,转到
    7. Delay3执行。——2机器周期时间
    8. DJNZ R6,Delay2
    9. DJNZ R5,Delay1
    复制代码


    此时时间总计:250*200*25*4μs+200*25*6μs+25*6μs=5030150μs。时间占用误差反而比未改进的时候大,可修正,将R7-30150/(25*200*4)=248(因为R7=250循环1次占用2个机器周期,4μs,计算等于R7-1.5075,将时间减小到小于5ms,剩余时间另补,取248)。则:
    时间总计:248*200*25*4μs+200*25*6μs+25*6μs=4990150μs,需要补:5000000-4990150=9850μs,9850/2=4925机器周期。补一个MOV R4,#200,4个NOP,还需4920机器周期,将其约分,得到24*205=4920。如何建立函数根据实际代码调整,如下:

    1.  
    2. Delay: MOV R5,#25 ;5ms延时——MOV指令占用1机器周期时间
    3. Delay1: MOV R6,#200 ;200ms延时
    4. Delay2: MOV R7,#250 ;1ms延时常数
    5. Delay3: ;NOP ;空指令,什么都不做,停留1机器周期时间
    6. DJNZ R7,Delay3 ;R7减1赋值给R7,如果此时R7不等于零,转到Delay3执行。——2机器周期时间
    7.  
    8. DJNZ R6,Delay2
    9. DJNZ R5,Delay1
    10. NOP
    11. NOP
    12. NOP
    13. NOP
    14. MOV R3,#6
    15. Delayadd: MOV R4,#205
    16. MOV R2,#0H
    17. DJNZ R3,Delayadd
    复制代码


    解析205*24调整为205*6——这是因为Delay循环为4机器周期代码,因此将24/4=6。请计算:205*6*4=4920;4920+5=4925。时间补充正好。此时时间计算:
    248*200*25*4μs+200*25*6μs+25*6μs=4990150μs+4925*2μs=5000000μs合计5ms。
    理论上1μs都不差(仅为科学探讨,具体晶振频率的误差多大作者并不明确)。

    展开全文
  • VB优于Sleep的延时函数,CPU哈(完美延时)
  • 在51单片机中1个机器周期由6个状态周期组成,也就是12个时钟周期=12 x 1/12 us =1 us 定义机器周期是因为时钟周期时间太短,根本做了什么。 3、指令周期:定义为执行一条指令所需的时间。 通常,包含一个机器周期...
  • //=========================================================================  // 函数名称: ...明: void 高精度延时,cpu占用低,窗口卡死,一次最大可延时几年   //========================
  • Qt延时占用CPU的问题解决

    千次阅读 2015-10-22 14:37:52
    1、使用时间轮询查看,卡界面,但是 cpu 被占的杠杠的,起码50%以上。 void MySleep(unsigned int msec) { QTime dieTime = QTime::currentTime().addMSecs(msec); while(QTime::currentTime() dieTime ){
  • 一个C++工程CPU占用100%问题的排查

    万次阅读 2021-11-12 08:31:18
    最近遇到一个 C++ 工程CPU占用100%的问题,经过排查,发现原来是不再使用的代码片段的问题,本文记录了排查的过程,并给出示例代码片段。
  • 如果此时我们使用 top 命令可以看到他们占用CPU的情况。 扩展:命令学习 pv命令是Pipe Viewer 的简称。 由Andrew Wood 开发。意思是通过管道显示数据处理进度的信息。 这些信息包括已经耗费的时间,完成的百分比...
  • 实现延时通常有两种方法:一种是硬件延时,要用到定时器/计数器,这种方法可以提高CPU的工作效率,也能做到延时;另一种是软件延时,这种方法主要采用循环体进行。  1 、使用定时器/计数器实现延时  单片机系统...
  • 一、程序做措施,cpu占用率 while 1: print(123) 一个简单的while循环的cpu占用率竟然达到了8%,低端机可能更高50%以上。cpu占用率太高会造成卡段影响电脑使用,那有什么办法解决吗? 答:给循环加个毫秒级别...
  • Linux 线程CPU占用率过高定位分析

    千次阅读 2020-07-21 23:01:55
    CPU占用过高,模拟CPU占用过高的情况 先上一段代码: #include <iostream> #include <thread> #include <vector> int main(int argc, char **argv) { std::vector<std::thread> test_...
  • 实现延时通常有两种方法:一种是硬件延时,要用到定时器/计数器,这种方法可以提高CPU的工作效率,也能做到精确延时;另一种是软件延时,这种方法主要采用循环体进行。 1 使用定时器/计数器实现精确延时 单片机系统...
  • 运行时发现cpu占用率高,核心温度高的不像话,光在空循环就能达到将近90度 解决方案: #include<Windows.h> while(expression){ //此处为代码 Sleep(500);//参数为毫秒 } 引用了Windows.h文件,使用...
  • STM32F103延时函数

    2016-02-17 17:09:54
    利用FOR循环,通过示波器观察,针对STM32F103进行的us,ms,s的延时,精度稍有误差,影响使用
  • C语言:程序的CPU占用率过大

    千次阅读 2019-04-02 19:15:44
    本身程序没有多少耗费cpu的操作,但是使用top命令查看的cpu占用率...对于pthread_cond_timedwait函数来说,是怎么占用cpu的。 使用例程可以参考如下: struct timespec ts; //超时时间设置 默认3秒 int time_nu...
  • docker查看容器的cpu占用

    万次阅读 2019-05-24 20:05:05
    压测导致的该服务数据过多,每个接口进行调用数据时都会产生很大的延时,导致cpu占用规则跳动,删除压测的数据,释放了部分数据库数据,但是指标治本,想着接下来看看mycat,redis好像压测也会因为内存使用...
  • linux中Select 函数占用cpu过高问题

    千次阅读 2014-12-26 21:38:06
    这几天用select函数发现用select函数占用的cpu过高,虽然我已经设置了阻塞时间。 这是因为select函数是会修改时间变量timeval结构体的...每次循环都会设置都把tv(就是timeval结构体)的设置为3s,这样几乎不会占用cpu
  • /proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间。它以文件系统的方式为内核与进程提供通信的接口。用户和应用程序可以通过**/proc得到系统的信息,并可以改变内核的某些参数。由于系统的信息,...
  • 外在表现:对于GUI程序而言,用户操作时界面是否卡顿,操作是否有延时,对于非GUI程序而言,程序是否反应及时,这些体现了CPU使用情况。 内在指标:指令的运行时长,GUI程序卡顿现象是操作延时过大给人的感觉,这些...
  • 最近笔者遇到这样一个相对比较疑难的事件,某个在Linux下运行的杀毒软件启动后在,某些情况下CPU占用率会持续升高,而且在交易量较高的情况下极易复现。而奇怪的是我们之前已经对于杀毒软件的CPU使用率进行了上限...
  • sleep会让出cpu吗 linux sleep 时占CPU

    千次阅读 2021-05-13 23:52:11
    一个线程处于sleep状态时它会消耗CPU吗?为什么?...占用CPU资源?如题。另外想问怎么能看到具体占用了多少资源,而不是ps里边的看占了百楼上明显答非所问。sleep()是阻塞,就是你所说的睡眠,...
  • VB.NET延时程序

    2019-04-28 16:27:35
    VB.NET2005 延时程序 占用少量CPU 实现设定的延时
  • Linux内核中的延时函数详解

    千次阅读 2021-12-06 21:41:57
    本文讲述了内核中涉及的两种不同性质的延时函数,并分析了各自的应用场景。
  • 当前项目使用第二个CPU Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)2; Thread T_GetFiles = new Thread(new ThreadStart(ThreadGetFiles));//获取文件线程 T_GetFiles.Start(); ...
  • 如果是仅仅做界面的话,Qt框架本身就是跨平台的,需要额外的操作。但是如果涉及到一些和平台自身特性相关的操作的时候,这部分代码就无法实现跨平台了。针对平台特性相关的代码,我们采用宏定义和qmake,在不同的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,088
精华内容 14,435
关键字:

不占用cpu的延时