尝试理解 Haskell STM 简单的事情

Question

我陷入了对 STM 中“原子”概念的理解中。

我用一个例子来说明

import Control.Concurrent
import Control.Concurrent.STM
import Control.Monad
import qualified Data.Map as Map 

main :: IO ()
main =  do
    d <- atomically$ newTVar Map.empty
    sockHandler  d 

sockHandler ::  TVar (Map.Map String Int)-> IO ()
sockHandler  d = do
    forkIO $ commandProcessor  d 1
    forkIO $ commandProcessor  d 2
    forkIO $ commandProcessor  d 3
    forkIO $ commandProcessor  d 4
    forkIO (threadDelay 1000 >> putStrLn "Hello World?")

    threadDelay 10000
    return ()

commandProcessor ::  TVar (Map.Map String Int)-> Int-> IO ()
commandProcessor  d i= do
  addCommand d i
  commandProcessor  d i 

addCommand  ::  TVar (Map.Map String Int) ->Int -> IO ()
addCommand    d i = do
  succ <- atomically $ runAdd d
  putStrLn  $"Result of add in " ++ (show i)++ " " ++( show succ)

runAdd  d =do
  dl <- readTVar d
  let (succ,g)= if   Map.member "a" dl
                  then
                      (False,dl)
                  else
                      (True,Map.insert "a" 9 dl)
  writeTVar d g
  return succ

示例输出将如下所示：

添加结果 1 True 添加结果 in 4 False 添加 in 1 的结果 FalseResult 添加 2 FalseResult 添加 3 个 False Hello World？结果 添加 4 个错误

add 的结果 1 个 FalseResult of add in 2 False 添加结果 in 3 False 添加结果 4 False

添加结果 1 False 添加结果 in 2 FalseResult of add in 3 False 添加 4 False 结果

添加结果 1 False 添加结果 in 2 FalseResult of add in 3 False 添加 4 False 结果

添加结果 1 False 添加结果 in 2 FalseResult of add in 4 False 添加 3 False 结果

添加结果 1 False 添加结果 in 4 添加到 2 的 FalseResult False 添加 3 False 结果

add 的结果 1 个 FalseResult of add in 4 False 添加 in 2 False 的结果 添加结果 3 False

add 的结果 1 个 FalseResult of add 4 错误

add的结果 2 FalseResult of add 3 错误

add 的结果 1 个 FalseResult of add 4 错误

add的结果 2 FalseResult of add in 3 False 添加 in 1 False 的结果 添加结果 4 False

add的结果 2 FalseResult of add 3 错误

add 的结果 1 个 FalseResult of add 4 错误

当我读到atomically

。这意味着事务内的所有操作完全完成，没有任何其他线程修改事务正在使用的变量，或者失败，状态将回滚到事务开始之前的位置。简而言之，原子事务要么完全完成，要么就好像它们根本没有运行过。

那么问题来了，在某些情况下，succ 的“返回”是否永远不会发生？ 那就是可以的线 succ <- 原子地 $ runAdd d putStrLn $"Add in " ++ (show i)++ " " ++( show succ)

给出的输出为 "Result of add in ?i " ("就好像它们根本没有运行过一样")

Answer 1

如果事务确实回滚，您的程序会再次尝试。您可以将atomically 的实现想象成这样：

atomically action = do varState <- getStateOfTVars
                       (newState, ret) <- runTransactionWith action varState
                       success <- attemptToCommitChangesToTVars newState
                       if success
                         then return ret
                         else atomically action -- try again

在您的情况下，事务将始终运行并始终完成。由于冲突，它可能会在第二次或第三次尝试时完成，但这对用户来说是不可见的。 STM 确保操作以原子方式发生，即使需要经过几次操作才能成功完成。

Answer 2

1. threadDelay 已经 returns ()，之后不需要显式 return ()
2. newTVarIO 是 atomically 的简洁版本。新TVar。
3. 如果您使用 forever 而不是像 commandProcessor 中那样尾部调用自己，那么它的可读性会更高。

至于你的问题，答案是“是”。这称为活锁，其中您的线程有工作要做，但无法取得进展。想象一下一个非常昂贵的函数，expcious，和一个非常便宜的函数，cheap。如果这些函数在同一 TVar 上的竞争性原子块中运行，那么廉价函数可能会导致昂贵函数永远无法完成。我为相关的SO问题构建了一个示例。

不过，您的结束示例并不完全正确，如果 STM 操作从未​​完成，则将永远无法到达 putStrLn，并且该线程根本看不到任何输出。