PAYATHON 2026

如何在 Haskell 中让 lazy IO 的等待并发进行?

技术老齐

可以在 IO 层显式安排两个等待过程并发执行,再把结果传给纯函数 f。对于 f :: Int -> Int -> Int,没有可靠的纯函数接口能启动、等待和管理这些 IO 操作。par 可能触发隐藏在 lazy IO 中的操作,但无法保证所需的并发行为。

为什么原程序会依次等待

unsafeInterleaveIO 会推迟 IO 操作,直到返回值被求值时才执行。因此,执行下面两行代码后,两个查询可能尚未完成,甚至还没开始:

a <- makeA
b <- makeB

此时,a 和 b 都可能还是尚未求值的 thunk。

当 print c 需要加法结果时,求值才会触发查询。如果当前线程先求值 a,就会等待 a 返回,再求值 b,于是出现示例中的顺序输出。但纯表达式中隐藏 IO 的执行顺序并没有这样的保证。

用 concurrently 显式运行两个查询

先去掉 unsafeInterleaveIO,让查询成为普通的 IO action,再使用 async 包中的 concurrently:

import Control.Concurrent (threadDelay)
import Control.Concurrent.Async (concurrently)

makeA :: IO Int
makeA = do
  putStrLn "Querying a"
  threadDelay 1000000
  putStrLn "Got a"
  return 1

makeB :: IO Int
makeB = do
  putStrLn "Querying b"
  threadDelay 1000000
  putStrLn "Got b"
  return 2

f :: Int -> Int -> Int
f a b = a + b

main :: IO ()
main = do
  (a, b) <- concurrently makeA makeB
  print (f a b)

项目需要声明对 async 包的依赖。concurrently 的类型是:

concurrently :: IO a -> IO b -> IO (a, b)

它并发执行两个 action,等两者都成功后返回结果。如果其中一个抛出异常,它会取消另一个,并将异常传播给调用方。

这个例子中的两次 threadDelay 可以重叠等待。没有明显额外开销时,总耗时应接近一次等待的时间。日志的具体顺序取决于调度,不应写死。

threadDelay 这样的等待不要求多个 CPU 核,也不需要启用 +RTS -N2 就能并发进行。如果实际查询使用了会阻塞运行时的外部调用,还需要检查 FFI 声明和 -threaded 等配置。

为什么不应依赖 par

给原表达式加上括号,可以写成:

a `par` (b `seq` f a b)

par 为 a 创建一个供运行时调度的 spark,让它有机会被并行求值。第二个参数中的 seq 则要求先将 b 求值到弱头范式(WHNF),再得到后续结果。

a 和 b 的求值都隐藏着 IO 操作。如果它们在不同的执行线程中求值,两个查询就可能同时等待。

不过,spark 只是并行求值的提示,并不保证启动另一个线程来完成操作。运行时可以不执行这个 spark,也可能等到当前线程需要 a 时才对它求值。par 也不提供 IO 任务所需的异常传播、取消和资源生命周期管理。

对于纯计算,这种调度差异通常只影响性能;加入 lazy IO 后,它还会影响可观察的副作用。因此,即使示例出现了并发输出,也不能据此认为这种写法能可靠地安排查询。

暂时无法移除 lazy IO 时怎么办

如果现有接口已经返回了延迟值,可以在 IO 层并发强制求值:

import Control.Concurrent.Async (concurrently)
import Control.Exception (evaluate)

main :: IO ()
main = do
  a <- makeA
  b <- makeB
  (a', b') <- concurrently (evaluate a) (evaluate b)
  print (f a' b')

这里的 makeA、makeB 使用题目中保留了 unsafeInterleaveIO 的定义。evaluate 把求值放进 IO action,concurrently 再并发执行这两个求值过程。

这可以作为过渡方案,使用时需要注意求值深度:

  • evaluate 只求值到 WHNF。对于示例中的 Int,这足以触发查询并取得数值。
  • 对于列表、树或带有惰性字段的结构,求值到 WHNF 不代表已经读取全部内容。即使并发执行了返回 lazy value 的 action,也不能保证后续读取会并发发生。
  • 对于有限且具有 NFData 实例的数据,可以使用 evaluate (force value) 强制求值到范式;无限流不能这样整体求值。
  • 如果延迟读取依赖文件句柄或连接,必须在资源仍然有效时完成所需的求值。

如果想封装并发取值后应用 f 的过程,可以增加一个明确返回 IO 的函数:

fIO :: IO Int -> IO Int -> IO Int
fIO getA getB =
  uncurry f <$> concurrently getA getB

调用方通过 fIO makeA makeB 安排并发查询,f 只负责计算。并发安排保留在类型可见的 IO 层,才能可靠地让两个查询同时等待。

备注:内容仅供参考。