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

mingkuang-Chuyu · mingkuang-Chuyu · commit 255de6f81031 · 2025-11-21T12:03:40.000+08:00
diff --git a/include/YY/Base/Threading/TaskRunner.h b/include/YY/Base/Threading/TaskRunner.h
@@ -65,7 +65,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
@@ -34,15 +34,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()
@@ -52,20 +55,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();
                         // 任务被取消？
@@ -75,7 +83,8 @@ namespace YY
                         uExpire = _uExpire;
                         return _pOwnerTaskRunner->SetTimerInternal(this);
                     }
-                    return S_OK;
+
+                    return _hr;
                 }
             }
 
@@ -311,35 +320,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);
                 }
 
@@ -461,21 +465,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;
             }
 
             void __YYAPI Wait::Cancel()
diff --git a/src/YY/Base/Threading/ThreadTaskRunnerImpl.cpp b/src/YY/Base/Threading/ThreadTaskRunnerImpl.cpp
@@ -255,8 +255,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);
                 }
 
@@ -285,11 +287,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())
                 {
@@ -309,8 +317,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 (_pTask->hThreadPoolWait)
                 {

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ namespace YY`
`65`	`65`
`66`	`66`	`void __YYAPI operator()()`
`67`	`67`	`{`
`68`		`- Wakeup(RunTask());`
	`68`	`+ RunTask();`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`/// <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
`@@ -34,15 +34,18 @@ namespace YY`
`34`	`34`	`if (IsCanceled())`
`35`	`35`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`36`	`36`
	`37`	`+ HRESULT _hr = S_OK;`
`37`	`38`	`try`
`38`	`39`	`{`
`39`	`40`	`pfnTaskCallback();`
`40`		`- return S_OK;`
`41`	`41`	`}`
`42`	`42`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`43`	`43`	`{`
`44`		`- return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`44`	`+ _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`45`	`45`	`}`
	`46`	`+`
	`47`	`+ Wakeup(_hr);`
	`48`	`+ return _hr;`
`46`	`49`	`}`
`47`	`50`
`48`	`51`	`HRESULT __YYAPI Timer::RunTask()`
`@@ -52,20 +55,25 @@ namespace YY`
`52`	`55`
`53`	`56`	`if (uInterval.GetTotalMilliseconds() <= 0)`
`54`	`57`	`{`
	`58`	`+ return TaskEntry::RunTask();`
	`59`	`+ }`
	`60`	`+ else`
	`61`	`+ {`
	`62`	`+ HRESULT _hr = S_OK;`
	`63`	`+ bool _bRet = false;`
	`64`	`+ auto _uExpire = TickCount::GetNow() + uInterval;`
`55`	`65`	`try`
`56`	`66`	`{`
`57`		`- pfnTaskCallback();`
`58`		`- return S_OK;`
	`67`	`+ _bRet = pfnTimerCallback();`
`59`	`68`	`}`
`60`	`69`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`61`	`70`	`{`
`62`		`- return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`71`	`+ _hr = YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`63`	`72`	`}`
`64`		`- }`
`65`		`- else`
`66`		`- {`
`67`		`- auto _uExpire = TickCount::GetNow() + uInterval;`
`68`		`- if (pfnTimerCallback())`
	`73`	`+`
	`74`	`+ Wakeup(_hr);`
	`75`	`+`
	`76`	`+ if (_bRet)`
`69`	`77`	`{`
`70`	`78`	`auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get();`
`71`	`79`	`// 任务被取消？`
`@@ -75,7 +83,8 @@ namespace YY`
`75`	`83`	`uExpire = _uExpire;`
`76`	`84`	`return _pOwnerTaskRunner->SetTimerInternal(this);`
`77`	`85`	`}`
`78`		`- return S_OK;`
	`86`	`+`
	`87`	`+ return _hr;`
`79`	`88`	`}`
`80`	`89`	`}`
`81`	`90`
`@@ -311,35 +320,30 @@ namespace YY`
`311`	`320`	`HRESULT __YYAPI TaskRunner::SetTimerInternal(RefPtr<Timer> _pTask)`
`312`	`321`	`{`
`313`	`322`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`323`	`+ _pTask->hr = E_PENDING;`
`314`	`324`
`315`	`325`	`if (_pTask->IsCanceled())`
`316`	`326`	`{`
	`327`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`317`	`328`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`318`	`329`	`}`
`319`		`-`
`320`		`- if (_pTask->uExpire.GetTicks() == 0)`
`321`		`- return PostTaskInternal(std::move(_pTask));`
`322`		`-`
`323`		`- // 现在的时间已经比过期时间大，那么立即触发任务，降低延迟`
`324`		`- auto _uCurrent = TickCount::GetNow();`
`325`		`- if (_pTask->uExpire <= _uCurrent)`
	`330`	`+ else if (_pTask->uExpire.GetTicks() == 0 \|\| (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)`
`326`	`331`	`{`
`327`		`- _pTask->uExpire = _uCurrent;`
`328`	`332`	`return PostTaskInternal(std::move(_pTask));`
`329`	`333`	`}`
`330`		`- else`
`331`		`- {`
`332`		`- TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));`
`333`		`- return S_OK;`
`334`		`- }`
	`334`	`+`
	`335`	`+ TaskRunnerDispatch::Get()->SetTimerInternal(std::move(_pTask));`
	`336`	`+ return S_OK;`
`335`	`337`	`}`
`336`	`338`
`337`	`339`	`HRESULT __YYAPI TaskRunner::SetWaitInternal(RefPtr<Wait> _pTask)`
`338`	`340`	`{`
`339`	`341`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`342`	`+ _pTask->hr = E_PENDING;`
`340`	`343`
`341`	`344`	`if (_pTask->IsCanceled())`
`342`	`345`	`{`
	`346`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`343`	`347`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`344`	`348`	`}`
`345`	`349`
`@@ -461,21 +465,27 @@ namespace YY`
`461`	`465`	`if (IsCanceled())`
`462`	`466`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`463`	`467`
	`468`	`+ HRESULT _hr = S_OK;`
	`469`	`+ bool _bRet = false;`
`464`	`470`	`try`
`465`	`471`	`{`
`466`		`- if (pfnWaitTaskCallback(uWaitResult))`
`467`		`- {`
`468`		`- if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())`
`469`		`- {`
`470`		`- _pOwnerTaskRunner->SetWaitInternal(this);`
`471`		`- }`
`472`		`- }`
`473`		`- return S_OK;`
	`472`	`+ _bRet = pfnWaitTaskCallback(uWaitResult);`
`474`	`473`	`}`
`475`	`474`	`catch (const YY::Base::OperationCanceledException& _Exception)`
`476`	`475`	`{`
`477`		`- return HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`476`	`+ _hr = HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`478`	`477`	`}`
	`478`	`+`
	`479`	`+ Wakeup(_hr);`
	`480`	`+ if (_bRet)`
	`481`	`+ {`
	`482`	`+ if (auto _pOwnerTaskRunner = pOwnerTaskRunnerWeak.Get())`
	`483`	`+ {`
	`484`	`+ _pOwnerTaskRunner->SetWaitInternal(this);`
	`485`	`+ }`
	`486`	`+ }`
	`487`	`+`
	`488`	`+ return _hr;`
`479`	`489`	`}`
`480`	`490`
`481`	`491`	`void __YYAPI Wait::Cancel()`
Original file line number	Diff line number	Diff line change
`@@ -255,8 +255,10 @@ namespace YY`
`255`	`255`
`256`	`256`	`HRESULT __YYAPI ThreadTaskRunnerImpl::PostTaskInternal(RefPtr<TaskEntry> _pTask)`
`257`	`257`	`{`
	`258`	`+ _pTask->hr = E_PENDING;`
`258`	`259`	`if (bStopWakeup)`
`259`	`260`	`{`
	`261`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`260`	`262`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`261`	`263`	`}`
`262`	`264`
`@@ -285,11 +287,17 @@ namespace YY`
`285`	`287`	`HRESULT __YYAPI ThreadTaskRunnerImpl::SetTimerInternal(RefPtr<Timer> _pTask)`
`286`	`288`	`{`
`287`	`289`	`_pTask->pOwnerTaskRunnerWeak = this;`
	`290`	`+ _pTask->hr = E_PENDING;`
`288`	`291`
`289`	`292`	`if (_pTask->IsCanceled())`
`290`	`293`	`{`
	`294`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`291`	`295`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
`292`	`296`	`}`
	`297`	`+ else if (_pTask->uExpire.GetTicks() == 0 \|\| (_pTask->uExpire - YY::TickCount::GetNow()).GetTotalMilliseconds() <= 0)`
	`298`	`+ {`
	`299`	`+ return PostTaskInternal(RefPtr<TaskEntry>(std::move(_pTask)));`
	`300`	`+ }`
`293`	`301`
`294`	`302`	`if (uThreadId != GetCurrentThreadId())`
`295`	`303`	`{`
`@@ -309,8 +317,12 @@ namespace YY`
`309`	`317`	`if (_pTask == nullptr \|\| _pTask->hHandle == NULL)`
`310`	`318`	`return E_INVALIDARG;`
`311`	`319`
	`320`	`+ _pTask->hr = E_PENDING;`
`312`	`321`	`if (_pTask->IsCanceled())`
	`322`	`+ {`
	`323`	`+ _pTask->Wakeup(YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED));`
`313`	`324`	`return YY::Base::HRESULT_From_LSTATUS(ERROR_CANCELLED);`
	`325`	`+ }`
`314`	`326`
`315`	`327`	`if (_pTask->hThreadPoolWait)`
`316`	`328`	`{`