except: lambda, comment, history

Author: fchn289

src/safe_mem/SafePtr.hpp

@@ -19,7 +19,6 @@
 //   . under single thread
 //     . so eg after MtInQueue.mt_push(), shall NOT touch pushed SafePtr
 //     . only HID is MT safe that can be used here
-//   . no exception
 //   . T's duty to ensure it's inner safety (eg no exception from T's constructor)
 //   . loop-ref: out-duty, usr issue than SafePtr
 //   . safe ptr array: no need since std::array
@@ -185,7 +184,7 @@ template<typename U, typename... ConstructArgs>
 SafePtr<U> make_safe(ConstructArgs&&... aArgs) noexcept
 {
     SafePtr<U> safeU;
-    try {
+    try {  // bad_alloc, or except from U's constructor
         safeU.pT_ = std::make_shared<U>(std::forward<ConstructArgs>(aArgs)...);  // std::make_shared, not boost's
         // HID("new ptr=" << (void*)(safeU.pT_.get()));  // too many print; void* print addr rather than content(dangeous)
     } catch(...) {
@@ -259,14 +258,9 @@ SafeWeak<T>::SafeWeak(const SafePtr<T>& aSafeFrom) noexcept
 template<typename T>
 SafePtr<T> SafeWeak<T>::lock() const noexcept
 {
-    SafePtr<T> ret;
-    if (pT_.expired())
-        return ret;
-
-    ret.pT_ = pT_.lock();
-    ret.realType_ = realType_;
-    ret.lastType_ = lastType_;
-    return ret;
+    return (pT_.expired())
+        ? nullptr
+        : SafePtr<T>(pT_.lock(), realType_, lastType_);  // constructor is faster
 }
 }  // namespace
 
@@ -289,7 +283,7 @@ struct std::hash<rlib::SafePtr<T>>
 // 2024-06-28  CSZ       - dynamic_pointer_cast ok or ret null
 // 2024-10-16  CSZ       - dynamic_pointer_cast to safe_cast since std not allowed
 // 2025-02-13  CSZ       4)SafeWeak
-// 2025-03-24  CSZ       5)enable exception, tolerate except is safer
+// 2025-03-24  CSZ       5)enable exception: tolerate except is safer; can't recover except->terminate
 // ***********************************************************************************************
 // - Q&A
 //   . How to solve safety issue:

src/thread/AsyncBack.cpp

@@ -18,12 +18,12 @@ bool AsyncBack::newTaskOK(const MT_TaskEntryFN& mt_aEntryFN, const TaskBackFN& a
             return false;
 
         // create new thread
-        // - ensure AsyncBack alive when thread alive - yes since ~AsyncBack() will wait all fut over
+        // - impossible thread alive but AsyncBack destructed, since ~AsyncBack() will wait all fut over
         auto fut = async(
             launch::async,
             // - must cp mt_aEntryFN than ref, otherwise dead loop
             // - &mt_nDoneFut is better than "this" that can access other non-MT-safe member
-            [mt_aEntryFN, &mt_nDoneFut = mt_nDoneFut_]()  // thread main
+            [mt_aEntryFN, &mt_nDoneFut = mt_nDoneFut_]() noexcept  // thread main
             {
                 SafePtr ret;
                 try { ret = mt_aEntryFN(); }

src/thread/AsyncBack.hpp

@@ -42,12 +42,8 @@
 //   . no duty to any unsafe behavior of MT_TaskEntryFN & TaskBackFN
 // - MT safe:
 //   . MT_/mt_ prefix: yes
-//   . others: NO (only use in main thread - most dom lib code shall in main thread - simple & nsesilbe)
-//     . AsyncBack can call mt_inMyMainTH() to ensure this
-//     . but can all rlib func call mt_inMyMainTH()? little benefit so giveup
-//       * common sense/principle: rlib (include AsyncBack) not call mt_inMyMainTH()
-//       . mt_inMyMainTH() for user debug - any main-thread func shall ret T if call mt_inMyMainTH()
-// - Exception-safe: follow noexcept-declare
+//   . others: NO (only in main thread - most dom lib code shall be in main thread - simple)
+//     . mt_inMyMainTH() for user debug - any main-thread func shall ret true if call mt_inMyMainTH()
 // ***********************************************************************************************
 #pragma once
 
@@ -77,7 +73,7 @@ class AsyncBack : public ThreadBack
 // 2023-09-14  CSZ       2)align with MsgSelf
 // 2023-10-25  CSZ       - with semaphore's wait-notify
 // 2024-07-10  CSZ       - mv common to base=ThreadBack
-// 2025-03-21  CSZ       3)enhance to avoid hang; enable exception for safety
+// 2025-03-21  CSZ       3)enable exception: tolerate except is safer; can't recover except->terminate
 // ***********************************************************************************************
 // - Q&A:
 //   . MT_/mt_ prefix

src/thread/MtInQueue.hpp

@@ -175,5 +175,5 @@ MtInQueue& mt_getQ() noexcept;
 // 2024-02-15  CSZ       3)use SafePtr (mem-safe); shared_ptr is not mem-safe
 // 2024-03-10  CSZ       - enhance safe of setHdlrOK()
 // 2024-10-05  CSZ       - integrate with domino (giveup since multi-same-type)
-// 2025-03-24  CSZ       4)enable exception: tolerate except is safer; can't recover->terminate
+// 2025-03-24  CSZ       4)enable exception: tolerate except is safer; can't recover except->terminate
 // ***********************************************************************************************

src/thread/ThPoolBack.cpp

@@ -25,7 +25,7 @@ ThPoolBack::ThPoolBack(size_t aMaxThread)
         thPool_.reserve(aMaxThread);  // not construct any thread
         for (size_t i = 0; i < aMaxThread; ++i)
         {
-            thread th([this]
+            thread th([this]() noexcept
             {   // thread main()
                 for (;;)
                 {

src/thread/ThPoolBack.hpp

@@ -15,7 +15,6 @@
 // - MT safe:
 //   . MT_/mt_ prefix: yes
 //   . others: no (must call in main thread)
-// - Exception-safe: follow noexcept-declare
 // ***********************************************************************************************
 #pragma once
 
@@ -36,7 +35,7 @@ class ThPoolBack : public ThreadBack
 public:
     // @brief Constructs a thread pool with exactly the specified number of threads.
     // @param aMaxThread: Exact number of threads to create (minimum 1).
-    // @throws runtime_error: If any thread cannot be created, ensuring the pool matches the requested size.
+    // @except if any thread cannot be created/joinable
     explicit ThPoolBack(size_t aMaxThread = 10) noexcept(false);
     ~ThPoolBack() noexcept;
 
@@ -59,5 +58,5 @@ class ThPoolBack : public ThreadBack
 // YYYY-MM-DD  Who       v)Modification Description
 // ..........  .........   .......................................................................
 // 2024-07-09  CSZ       1)create
-// 2025-03-21  CSZ       2)enhance to avoid hang; enable exception for safety
+// 2025-03-21  CSZ       2)enable exception: tolerate except is safer; can't recover except->terminate
 // ***********************************************************************************************

src/thread/ThreadBack.hpp

@@ -73,7 +73,7 @@ class ThreadBack
 // 2024-07-09  CSZ       1)create
 // 2024-08-05  CSZ       - mt_nDoneFut_ to improve iteration of fut_backFN_S_
 //                       - MT_TaskEntryFN ret SafePtr<void> instead of bool
-// 2025-03-21  CSZ       2)enhance to avoid hang; enable exception for safety
+// 2025-03-21  CSZ       2)enable exception: tolerate except is safer; can't recover except->terminate
 // ***********************************************************************************************
 // - why SafePtr
 //   . thread can ret any type data include bool

src/thread/ThreadBackViaMsgSelf.hpp

@@ -28,7 +28,7 @@ TaskBackFN viaMsgSelf(const TaskBackFN& aBackFN, EMsgPriority aPri = EMsgPri_NOR
     auto&& msgSelf = MSG_SELF;
     return ! aBackFN || msgSelf.get() == nullptr
         ? TaskBackFN()  // empty fn
-        : [aBackFN, msgSelf, aPri](SafePtr<void> aRet)  // must cp aBackFN since lambda run later in diff lifecycle
+        : [aBackFN, msgSelf, aPri](SafePtr<void> aRet) noexcept  // must cp aBackFN since lambda run later in diff lifecycle
         {
             msgSelf->newMsg(bind(aBackFN, aRet), aPri);  // wrap aBackFN to queue in MsgSelf
         };