F＃解決死鎖問題

Question

我對併發編程非常陌生，所以我遇到了一個需要解決的死鎖問題。

因此，對於下面的代碼，它不打印任何我認爲肯定會出現死鎖的東西，儘管我不太確定它是如何發生的。

let sleepMaybe() = if (random 4) = 1 then Thread.Sleep 5 

type account(name:string) = 
    let balance = ref 1000 
    member this.Balance = lock this <| fun() -> !balance 
    member this.Name = name 
    member this.Withdraw amount = balance := !balance - (sleepMaybe(); amount) 
    member this.Deposit amount = balance := !balance + (sleepMaybe(); amount) 

    member this.Transfer (toAcc:account) amount = 
     lock this <| fun() -> lock toAcc <| fun() -> toAcc.Deposit amount 
           this.Withdraw amount 


let doTransfers (acc:account) (toAcc:account)() = 
    for i in 1..100 do acc.Transfer toAcc 100 
    printfn "%s balance: %d Other balance: %d" acc.Name acc.Balance toAcc.Balance 

let q2main() = 
    let acc1=account("Account1") 
    let acc2=account("Account2") 

    startThread (doTransfers acc1 acc2) 
    startThread (doTransfers acc2 acc1) 

q2main()   

Answer 1

您正在鎖定實例本身並要求鎖定兩個實例才能傳輸內容。這是死鎖的祕訣。

• 線程ACC1 1把門鎖上開始ACC2轉移
• 線程2個鎖開始轉移
• 線程1個等待對ACC2的鎖被釋放，因此它可以完成其傳輸
• 線程2等待acc1上的鎖被釋放，以便它可以完成其傳輸

他們將各自等待對方無限期地釋放它們的鎖。

如果有一次獲得多個鎖，總是獲取相同的順序的鎖。也就是說，儘量不要通過改變你的對象職責來同時需要多個鎖。

例如，提款和存款是兩個不相關的獨立操作，但它們修改餘額。您正試圖用鎖鎖定餘額。一旦帳戶的餘額發生變化，保留該鎖就沒有意義了。另外，我建議賬戶的責任不在於知道如何轉移到其他賬戶。

考慮到這一點，以下是消除死鎖的變化。

type Account(name:string) = 
    let mutable balance = 1000 
    let accountSync = new Object() 

    member x.Withdraw amount = lock accountSync 
            (fun() -> balance <- balance - amount) 
    member x.Deposit amount = lock accountSync 
            (fun() -> balance <- balance + amount) 

let transfer amount (fromAccount:Account) (toAccount:Account) = 
    fromAccount.Withdraw(amount) 
    toAccount.Deposit(amount) 

Answer 2

克里斯解釋了死鎖的原因，但該解決方案必須包括用於傳輸（假定一個存款可能失敗由於透支等）的整體鎖定兩個帳戶。您正在努力爭取一種形式的事務內存。以下是一種方法：

open System 
open System.Threading 
open System.Threading.Tasks 

type Account(name) = 
    let mutable balance = 1000 
    member val Name = name 
    member __.Balance = balance 
    member private __.Deposit amount = 
    balance <- balance + amount 
    member val private Lock = obj() 
    member this.Transfer (toAccount: Account) amount = 
    let rec loop() = 
     let mutable retry = true 
     if Monitor.TryEnter(this.Lock) then 
     if Monitor.TryEnter(toAccount.Lock) then 
      this.Deposit(-amount) 
      toAccount.Deposit(amount) 
      Monitor.Exit(toAccount.Lock) 
      retry <- false 
     Monitor.Exit(this.Lock) 
     if retry then loop() 
    loop() 

let printLock = obj() 

let doTransfers (acc:Account) (toAcc:Account) threadName = 
    for i in 1..100 do 
     acc.Transfer toAcc 100 
     lock printLock (fun() -> 
     printfn "%s - %s: %d, %s: %d" threadName acc.Name acc.Balance toAcc.Name toAcc.Balance) 

[<EntryPoint>] 
let main _ = 
    let acc1 = Account("Account1") 
    let acc2 = Account("Account2") 
    Task.WaitAll [| 
     Task.Factory.StartNew(fun() -> doTransfers acc1 acc2 "Thread 1") 
     Task.Factory.StartNew(fun() -> doTransfers acc2 acc1 "Thread 2") 
    |] 
    printfn "\nDone." 
    Console.Read() 

Answer 3

這是dining philosophers problem。一般的解決方案是在拿取鎖前對你的鎖進行分類。