Question

我有以下Haskell代码，它应该实现一些基于STM的队列：

{-# LANGUAGE ScopedTypeVariables #-}
module Main where

import           Control.Concurrent.Async
import           Control.Concurrent.STM
import           Control.Exception
import           Control.Monad            (forever)
import           Hevents.Eff
import           System.IO

withStore :: (FileStorage -> IO a) -> IO a
withStore = bracket (openFileStorage "test.store") closeFileStorage

data Op = Op String (TMVar Int)

storerun :: TBQueue Op -> IO ()
storerun q = do
  h <- openFile "store.test" ReadWriteMode
  hSetBuffering h NoBuffering
  forever $ do
    Op s v <- atomically $ readTBQueue q
    hPutStrLn h s
    atomically $ putTMVar v (length s)


main :: IO ()
main = do
  q <- newTBQueueIO 100
  _ <- async $ storerun q
  storeInput q
  where
    storeInput q = forever $ do
      putStrLn "pushing"
      l <- getLine
      v <- newEmptyTMVarIO
      r <- atomically $ do
        writeTBQueue q (Op l v)
        takeTMVar v
      putStrLn $ "got " ++ show r

运行时，此代码会引发BlockedIndefinitelyOnSTM异常。如果我将storeInput函数更改为以下内容：

    storeInput q = forever $ do
      putStrLn "pushing"
      l <- getLine
      v <- atomically $ do
        v <- newEmptyTMVar
        writeTBQueue q (Op l v)
        return v
      r <- atomically $ takeTMVar v
      putStrLn $ "got " ++ show r

程序运行良好。

我对可能导致此异常的原因的理解是，STM事务中涉及的变量以某种方式被垃圾收集仅在retry的单个线程中可见，因此因为内容而被解锁事务变量永远不会改变。

在我的代码中，v结构中的Op变量在一个线程中创建，使用事务队列传递给另一个线程，然后由另一个线程使用，似乎没有理由因为它可以在任何线程中进行垃圾收集。

因此我不清楚为什么这段代码确实失败了。

Answer 1

交易是 atomic 。问题出在这里：

r <- atomically $ do
        writeTBQueue q (Op l v) -- (1)
        takeTMVar v             -- (2)

除非另一个线程在（1）和（2）之间执行putTMVar，否则这将阻止。原子性阻止了这一点。

在交易中，您不能发送信息＆＃34;到另一个交易，并期待＆＃34;回复＆＃34;从那以后。这将要求在前一个事务之前（逻辑上）执行前一个事务，反之亦然，这是不可能的。

我被STM封锁的确切原因是什么？

1 个答案: