Bug, 解决Wakeup时机滞后，可能导致Wait失败

mingkuang-Chuyu · mingkuang-Chuyu · commit 55ca0b632884 · 2025-11-23T15:12:07.000+08:00
diff --git a/include/YY/Base/Threading/TaskRunner.h b/include/YY/Base/Threading/TaskRunner.h
@@ -67,7 +67,7 @@ namespace YY
 
                 void __YYAPI operator()()
                 {
-                    Wakeup(RunTask());
+                    RunTask();
                 }
 
                 /// <summary>
diff --git a/src/YY/Base/Threading/ParallelTaskRunnerImpl.hpp b/src/YY/Base/Threading/ParallelTaskRunnerImpl.hpp
@@ -225,6 +225,7 @@ namespace YY
 
                     if (TaskRunnerFlags.bStopWakeup)
                     {
+                        _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                         return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                     }
 
diff --git a/src/YY/Base/Threading/SequencedTaskRunnerImpl.cpp b/src/YY/Base/Threading/SequencedTaskRunnerImpl.cpp
@@ -68,6 +68,7 @@ namespace YY
                 {
                     if (_fFlags & StopWakeupRaw)
                     {
+                        _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                         return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                     }
                     else if (_fFlags & (1 << LockedQueuePushBitIndex))
diff --git a/src/YY/Base/Threading/TaskRunner.cpp b/src/YY/Base/Threading/TaskRunner.cpp
@@ -52,15 +52,18 @@ namespace YY
                 if (IsCanceled())
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
 
+                HRESULT _hr = S_OK;
                 try
                 {
                     pfnTaskCallback();
-                    return S_OK;
                 }
                 catch (const YY::Base::OperationCanceledException& _Exception)
                 {
-                    return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
+                    _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
+
+                Wakeup(_hr);
+                return _hr;
             }
 
             HRESULT __YYAPI Timer::RunTask()
@@ -70,20 +73,25 @@ namespace YY
 
                 if (uInterval.GetTotalMilliseconds() <= 0)
                 {
+                    return TaskEntry::RunTask();
+                }
+                else
+                {
+                    HRESULT _hr = S_OK;
+                    bool _bRet = false;
+                    auto _uExpire = TickCount::GetNow() + uInterval;
                     try
                     {
-                        pfnTaskCallback();
-                        return S_OK;
+                        _bRet = pfnTimerCallback();
                     }
                     catch (const YY::Base::OperationCanceledException& _Exception)
                     {
-                        return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
+                        _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                     }
-                }
-                else
-                {
-                    auto _uExpire = TickCount::GetNow() + uInterval;
-                    if (pfnTimerCallback())
+
+                    Wakeup(_hr);
+
+                    if (_bRet)
                     {
                         auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get();
                         // 任务被取消？
@@ -93,7 +101,8 @@ namespace YY
                         uExpire = _uExpire;
                         return _pOwnerTaskRunner->SetTimerInternal(this);
                     }
-                    return S_OK;
+
+                    return _hr;
                 }
             }
 
@@ -338,35 +347,30 @@ namespace YY
             HRESULT __YYAPI TaskRunner::SetTimerInternal(RefPtr<Timer> _pTask)
             {
                 _pTask->pOwnerTaskRunnerWeak = this;
+                _pTask->hr = E_PENDING;
 
                 if (_pTask->IsCanceled())
                 {
+                    _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
-
-                if (_pTask->uExpire.GetTicks() == 0)
-                    return PostTaskInternal(std::move(_pTask));
-
-                // 现在的时间已经比过期时间大，那么立即触发任务，降低延迟
-                auto _uCurrent = TickCount::GetNow();
-                if (_pTask->uExpire <= _uCurrent)
+                else if (_pTask->uExpire.GetTicks() == 0 || (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)
                 {
-                    _pTask->uExpire = _uCurrent;
                     return PostTaskInternal(std::move(_pTask));
                 }
-                else
-                {
-                    TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));
-                    return S_OK;
-                }
+
+                TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));
+                return S_OK;
             }
 
             HRESULT __YYAPI TaskRunner::SetWaitInternal(RefPtr<Wait> _pTask)
             {
                 _pTask->pOwnerTaskRunnerWeak = this;
+                _pTask->hr = E_PENDING;
 
                 if (_pTask->IsCanceled())
                 {
+                    _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
 
@@ -493,21 +497,27 @@ namespace YY
                 if (IsCanceled())
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
 
+                HRESULT _hr = S_OK;
+                bool _bRet = false;
                 try
                 {
-                    if (pfnWaitTaskCallback(uWaitResult))
-                    {
-                        if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())
-                        {
-                            _pOwnerTaskRunner->SetWaitInternal(this);
-                        }
-                    }
-                    return S_OK;
+                    _bRet = pfnWaitTaskCallback(uWaitResult);
                 }
                 catch (const YY::Base::OperationCanceledException& _Exception)
                 {
-                    return HRESULT_From_LSTATUS(ERROR_CANCELLED);
+                    _hr = HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
+
+                Wakeup(_hr);
+                if (_bRet)
+                {
+                    if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())
+                    {
+                        _pOwnerTaskRunner->SetWaitInternal(this);
+                    }
+                }
+
+                return _hr;
             }
 
             bool __YYAPI Wait::Cancel()
diff --git a/src/YY/Base/Threading/ThreadTaskRunnerImpl.cpp b/src/YY/Base/Threading/ThreadTaskRunnerImpl.cpp
@@ -265,8 +265,10 @@ namespace YY
 
             HRESULT __YYAPI ThreadTaskRunnerImpl::PostTaskInternal(RefPtr<TaskEntry> _pTask)
             {
+                _pTask->hr = E_PENDING;
                 if (bStopWakeup)
                 {
+                    _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
 
@@ -295,11 +297,17 @@ namespace YY
             HRESULT __YYAPI ThreadTaskRunnerImpl::SetTimerInternal(RefPtr<Timer> _pTask)
             {
                 _pTask->pOwnerTaskRunnerWeak = this;
+                _pTask->hr = E_PENDING;
 
                 if (_pTask->IsCanceled())
                 {
+                    _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
                 }
+                else if (_pTask->uExpire.GetTicks() == 0 || (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)
+                {
+                    return PostTaskInternal(RefPtr<TaskEntry>(std::move(_pTask)));
+                }
 
                 if (uThreadId != GetCurrentThreadId())
                 {
@@ -319,8 +327,12 @@ namespace YY
                 if (_pTask == nullptr || _pTask->hHandle == NULL)
                     return E_INVALIDARG;
 
+                _pTask->hr = E_PENDING;
                 if (_pTask->IsCanceled())
+                {
+                    _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));
                     return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);
+                }
 
                 if (uThreadId != GetCurrentThreadId())
                 {

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ namespace YY`
`67`	`67`
`68`	`68`	`void __YYAPI operator()()`
`69`	`69`	`{`
`70`		`- Wakeup(RunTask());`
	`70`	`+ RunTask();`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -225,6 +225,7 @@ namespace YY`
`225`	`225`
`226`	`226`	`if (TaskRunnerFlags.bStopWakeup)`
`227`	`227`	`{`
	`228`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`228`	`229`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`229`	`230`	`}`
`230`	`231`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,7 @@ namespace YY`
`68`	`68`	`{`
`69`	`69`	`if (_fFlags & StopWakeupRaw)`
`70`	`70`	`{`
	`71`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`71`	`72`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`72`	`73`	`}`
`73`	`74`	`else if (_fFlags & (1 << LockedQueuePushBitIndex))`
Original file line number	Diff line number	Diff line change
`@@ -52,15 +52,18 @@ namespace YY`
`52`	`52`	`if (IsCanceled())`
`53`	`53`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`54`	`54`
	`55`	`+ HRESULT _hr = S_OK;`
`55`	`56`	`try`
`56`	`57`	`{`
`57`	`58`	`pfnTaskCallback();`
`58`		`- return S_OK;`
`59`	`59`	`}`
`60`	`60`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`61`	`61`	`{`
`62`		`- return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`62`	`+ _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`63`	`63`	`}`
	`64`	`+`
	`65`	`+ Wakeup(_hr);`
	`66`	`+ return _hr;`
`64`	`67`	`}`
`65`	`68`
`66`	`69`	`HRESULT __YYAPI Timer::RunTask()`
`@@ -70,20 +73,25 @@ namespace YY`
`70`	`73`
`71`	`74`	`if (uInterval.GetTotalMilliseconds() <= 0)`
`72`	`75`	`{`
	`76`	`+ return TaskEntry::RunTask();`
	`77`	`+ }`
	`78`	`+ else`
	`79`	`+ {`
	`80`	`+ HRESULT _hr = S_OK;`
	`81`	`+ bool _bRet = false;`
	`82`	`+ auto _uExpire = TickCount::GetNow() + uInterval;`
`73`	`83`	`try`
`74`	`84`	`{`
`75`		`- pfnTaskCallback();`
`76`		`- return S_OK;`
	`85`	`+ _bRet = pfnTimerCallback();`
`77`	`86`	`}`
`78`	`87`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`79`	`88`	`{`
`80`		`- return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`89`	`+ _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`81`	`90`	`}`
`82`		`- }`
`83`		`- else`
`84`		`- {`
`85`		`- auto _uExpire = TickCount::GetNow() + uInterval;`
`86`		`- if (pfnTimerCallback())`
	`91`	`+`
	`92`	`+ Wakeup(_hr);`
	`93`	`+`
	`94`	`+ if (_bRet)`
`87`	`95`	`{`
`88`	`96`	`auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get();`
`89`	`97`	`// 任务被取消？`
`@@ -93,7 +101,8 @@ namespace YY`
`93`	`101`	`uExpire = _uExpire;`
`94`	`102`	`return _pOwnerTaskRunner->SetTimerInternal(this);`
`95`	`103`	`}`
`96`		`- return S_OK;`
	`104`	`+`
	`105`	`+ return _hr;`
`97`	`106`	`}`
`98`	`107`	`}`
`99`	`108`
`@@ -338,35 +347,30 @@ namespace YY`
`338`	`347`	`HRESULT __YYAPI TaskRunner::SetTimerInternal(RefPtr<Timer> _pTask)`
`339`	`348`	`{`
`340`	`349`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`350`	`+ _pTask->hr = E_PENDING;`
`341`	`351`
`342`	`352`	`if (_pTask->IsCanceled())`
`343`	`353`	`{`
	`354`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`344`	`355`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`345`	`356`	`}`
`346`		`-`
`347`		`- if (_pTask->uExpire.GetTicks() == 0)`
`348`		`- return PostTaskInternal(std::move(_pTask));`
`349`		`-`
`350`		`- // 现在的时间已经比过期时间大，那么立即触发任务，降低延迟`
`351`		`- auto _uCurrent = TickCount::GetNow();`
`352`		`- if (_pTask->uExpire <= _uCurrent)`
	`357`	`+ else if (_pTask->uExpire.GetTicks() == 0 \|\| (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)`
`353`	`358`	`{`
`354`		`- _pTask->uExpire = _uCurrent;`
`355`	`359`	`return PostTaskInternal(std::move(_pTask));`
`356`	`360`	`}`
`357`		`- else`
`358`		`- {`
`359`		`- TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));`
`360`		`- return S_OK;`
`361`		`- }`
	`361`	`+`
	`362`	`+ TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));`
	`363`	`+ return S_OK;`
`362`	`364`	`}`
`363`	`365`
`364`	`366`	`HRESULT __YYAPI TaskRunner::SetWaitInternal(RefPtr<Wait> _pTask)`
`365`	`367`	`{`
`366`	`368`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`369`	`+ _pTask->hr = E_PENDING;`
`367`	`370`
`368`	`371`	`if (_pTask->IsCanceled())`
`369`	`372`	`{`
	`373`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`370`	`374`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`371`	`375`	`}`
`372`	`376`
`@@ -493,21 +497,27 @@ namespace YY`
`493`	`497`	`if (IsCanceled())`
`494`	`498`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`495`	`499`
	`500`	`+ HRESULT _hr = S_OK;`
	`501`	`+ bool _bRet = false;`
`496`	`502`	`try`
`497`	`503`	`{`
`498`		`- if (pfnWaitTaskCallback(uWaitResult))`
`499`		`- {`
`500`		`- if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())`
`501`		`- {`
`502`		`- _pOwnerTaskRunner->SetWaitInternal(this);`
`503`		`- }`
`504`		`- }`
`505`		`- return S_OK;`
	`504`	`+ _bRet = pfnWaitTaskCallback(uWaitResult);`
`506`	`505`	`}`
`507`	`506`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`508`	`507`	`{`
`509`		`- return HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`508`	`+ _hr = HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`510`	`509`	`}`
	`510`	`+`
	`511`	`+ Wakeup(_hr);`
	`512`	`+ if (_bRet)`
	`513`	`+ {`
	`514`	`+ if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())`
	`515`	`+ {`
	`516`	`+ _pOwnerTaskRunner->SetWaitInternal(this);`
	`517`	`+ }`
	`518`	`+ }`
	`519`	`+`
	`520`	`+ return _hr;`
`511`	`521`	`}`
`512`	`522`
`513`	`523`	`bool __YYAPI Wait::Cancel()`
Original file line number	Diff line number	Diff line change
`@@ -265,8 +265,10 @@ namespace YY`
`265`	`265`
`266`	`266`	`HRESULT __YYAPI ThreadTaskRunnerImpl::PostTaskInternal(RefPtr<TaskEntry> _pTask)`
`267`	`267`	`{`
	`268`	`+ _pTask->hr = E_PENDING;`
`268`	`269`	`if (bStopWakeup)`
`269`	`270`	`{`
	`271`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`270`	`272`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`271`	`273`	`}`
`272`	`274`
`@@ -295,11 +297,17 @@ namespace YY`
`295`	`297`	`HRESULT __YYAPI ThreadTaskRunnerImpl::SetTimerInternal(RefPtr<Timer> _pTask)`
`296`	`298`	`{`
`297`	`299`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`300`	`+ _pTask->hr = E_PENDING;`
`298`	`301`
`299`	`302`	`if (_pTask->IsCanceled())`
`300`	`303`	`{`
	`304`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`301`	`305`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`302`	`306`	`}`
	`307`	`+ else if (_pTask->uExpire.GetTicks() == 0 \|\| (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)`
	`308`	`+ {`
	`309`	`+ return PostTaskInternal(RefPtr<TaskEntry>(std::move(_pTask)));`
	`310`	`+ }`
`303`	`311`
`304`	`312`	`if (uThreadId != GetCurrentThreadId())`
`305`	`313`	`{`
`@@ -319,8 +327,12 @@ namespace YY`
`319`	`327`	`if (_pTask == nullptr \|\| _pTask->hHandle == NULL)`
`320`	`328`	`return E_INVALIDARG;`
`321`	`329`
	`330`	`+ _pTask->hr = E_PENDING;`
`322`	`331`	`if (_pTask->IsCanceled())`
	`332`	`+ {`
	`333`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`323`	`334`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`335`	`+ }`
`324`	`336`
`325`	`337`	`if (uThreadId != GetCurrentThreadId())`
`326`	`338`	`{`