Safe arithmetic ops

src/task/blocking.rs

@@ -260,7 +260,7 @@ fn create_blocking_thread() {
     let _ = thread::Builder::new()
         .name("async-blocking-driver-dynamic".to_string())
         .spawn(move || {
-            let wait_limit = Duration::from_millis(1000 + rand_sleep_ms);
+            let wait_limit = Duration::from_millis(1000_u64 + rand_sleep_ms);
 
             // Adjust the pool size counter before and after spawn
             *POOL_SIZE.lock().unwrap() += 1;
@@ -276,7 +276,12 @@ fn create_blocking_thread() {
                     // Also, some systems have it(like macOS), and some don't(Linux).
                     // This case expected not to happen.
                     // But when happened this shouldn't throw a panic.
-                    MAX_THREADS.store(*POOL_SIZE.lock().unwrap() - 1, Ordering::SeqCst);
+                    let guarded_count = POOL_SIZE
+                        .lock()
+                        .unwrap()
+                        .checked_sub(1)
+                        .expect("shouldn't underflow");
+                    MAX_THREADS.store(guarded_count, Ordering::SeqCst);
                 }
                 _ => eprintln!(
                     "cannot start a dynamic thread driving blocking tasks: {}",