如何结合safe-exceptions与async库捕获并处理异步异常？

嘿，我看你在Haskell并发代码里遇到了异常处理的棘手问题——尤其是用safe-exceptions和async库时，怎么区分异步异常（比如AsyncCancelled）和同步异常（比如网络IO错误），还有waitCatch识别不出IO异常的坑。我来帮你一步步理清楚：

你的代码里的核心问题：类型不匹配！ #

首先，你代码里的fromException始终返回Nothing，不是因为safe-exceptions或async的问题，而是类型搞错了：你在handler里尝试匹配IOError，但用throwTo抛出的userError "error"其实是IOException类型（注意末尾的Exception）。

IOError是base库中比较旧的类型别名，现在Haskell标准的IO异常类型是IOException。这就导致你用Maybe IOError去匹配IOException，自然得不到结果。

先给你修正后的代码，运行这个就能正常识别出IO异常了：

{-# LANGUAGE ScopedTypeVariables #-}
import Control.Concurrent.Async
import Control.Concurrent hiding (throwTo)
import Control.Exception.Safe
import Control.Monad
import System.IO
import System.IO.Error (isUserError)  -- 只导入需要的函数，避免类型混淆

main = do
  hSetBuffering stdin NoBuffering
  putStrLn "Press any key to continue..."
  a <- async runLoop
  async $ hWaitForInput stdin (-1) *> throwTo (asyncThreadId a) (userError "error")
  waitCatch a >>= either handler nothing
  where
    printThenWait i = putStr (show i ++ " ") *> threadDelay 1000000
    runLoop = sequence_ $ printThenWait <$> [1..]
    nothing _ = pure ()
    handler e
      | Just (e' :: IOException) <- fromException e = 
          if isUserError e' then putStrLn "It's a user IOException!" else putStrLn "It's an IO error!"
      | Just AsyncCancelled <- fromException e = putStrLn "Async action was cancelled!"
      | otherwise = putStrLn $ "Unexpected exception: " ++ show e

区分同步/异步异常，精准控制线程行为 #

safe-exceptions的核心设计就是帮你把同步异常（比如网络故障、文件读写错误）和异步异常（比如线程取消、超时）分开处理——因为异步异常是Haskell用来控制线程生命周期的关键机制，随便捕获很容易导致资源泄漏或死锁。

针对你说的“每隔n秒检查网络资源”的场景，我们可以这样设计处理逻辑：

• 网络故障（同步IOException）：捕获后忽略，继续下一次检查，或者执行重试
• AsyncCancelled（异步异常）：停止线程，顺便清理资源
• 其他致命同步异常：抛回主线程处理

方式1：在异步线程内部处理异常 #

如果希望异常处理逻辑内嵌在异步线程里，不用主线程操心，可以用safe-exceptions的普通catch或handle只处理同步异常，让异步异常（比如cancel触发的）正常终止线程：

runNetworkCheckLoop :: IO ()
runNetworkCheckLoop = forever $ do
  threadDelay 5000000  -- 每隔5秒检查一次
  -- 只捕获同步IO异常，异步异常会直接终止线程
  handle (\(e :: IOException) -> do
            putStrLn $ "Network check failed: " ++ show e
            threadDelay 1000000) $ do  -- 失败后延迟1秒再重试
    putStrLn "Checking network resource..."
    -- 模拟网络故障：50%概率抛出异常
    when (randomIO >>= (< 0.5)) $ ioError $ userError "Connection refused"

当你用cancel终止这个线程时，AsyncCancelled会直接打断forever循环，线程正常退出；而网络故障的异常会被捕获，线程继续运行。

方式2：在主线程用waitCatch统一处理 #

如果需要在主线程根据异步线程的异常类型做决策（比如要不要重启线程），可以用waitCatch获取最终结果，然后匹配不同的异常：

main = do
  checkThread <- async runNetworkCheckLoop
  putStrLn "Press 'q' to quit..."
  -- 等待用户输入'q'来取消线程
  void $ takeWhile (/= 'q') <$> getContents
  cancel checkThread
  waitCatch checkThread >>= \case
    Left e
      | Just AsyncCancelled <- fromException e -> putStrLn "Network check cancelled gracefully"
      | Just (ioe :: IOException) <- fromException e -> putStrLn $ "Check stopped with IO error: " ++ show ioe
      | otherwise -> putStrLn $ "Unexpected error: " ++ show e
    Right _ -> putStrLn "Check finished unexpectedly"

关于catchAsync：什么时候用才安全？ #

safe-exceptions把catchAsync标记为“危险”，是因为它能捕获所有异常，包括异步异常。而异步异常是Haskell实现线程取消、超时的核心手段，随便捕获可能导致：

• 线程无法被正常取消，占用资源不释放
• 死锁（比如线程持有锁时忽略了取消信号）

推荐的使用场景 #

只有当你明确需要在异步异常发生时执行清理逻辑，才用catchAsync——而且捕获后一定要重新抛出异常，让线程正常终止。比如：

runNetworkCheckLoop :: IO ()
runNetworkCheckLoop = catchAsync
  (forever $ do
     threadDelay 5000000
     handle (\(e :: IOException) -> putStrLn $ "Check failed: " ++ show e) $ do
       putStrLn "Checking network..."
       -- 模拟检查逻辑
       pure ())
  (\e -> do
     -- 只在取消时执行清理
     if Just AsyncCancelled == fromException e
       then putStrLn "Cleaning up network check resources..."
       else pure ()
     -- 重新抛出异常，保证线程能正常终止
     throwM e)

这里捕获了AsyncCancelled，执行完清理动作后重新抛出，既保证了资源被正确释放，又不会阻止线程被取消。

总结几个最佳实践 #

1. 优先区分同步/异步异常：用safe-exceptions的普通catch/handle处理同步异常，让异步异常自然传递以控制线程生命周期
2. 别乱捕获异步异常：只有需要清理资源时用catchAsync，而且必须重新抛出异常
3. 类型匹配要准确：别把IOError和IOException搞混，这是新手常踩的坑
4. 主线程统一管控：用waitCatch获取异步线程的最终状态，根据异常类型决定后续动作（比如重启线程、报警）

内容的提问来源于stack exchange，提问作者hololeap