【发布时间】：2017-03-25 10:28:41
【问题描述】：
在大学期间，我不得不用 Java 实现银行转账模拟。完成之后，我想在 Go 中实现它，因为我听说了很多关于 Go 的并发功能并想尝试一下。
我有两个聚会，foo 和 bar。每一方都有一份银行账户清单，其中包含余额和用于识别的号码。 foo 的每个账户都应该向 bar 的一个账户转移一定的金额。这些转账应该分成更小、更不可疑的转账，重复转账一个单位，直到全部转账。同时，bar 正在将相同的金额转回给 foo，因此 foo 和 bar 的账户的总和分别应该在开始和结束时相同。
这是我的帐户结构：
type Account struct {
Owner string
Number int
Balance int
}
func NewAccount(owner string, number int, balance int) *Account {
account := &Account{Owner: owner, Number: number, Balance: balance}
return account
}
func (account Account) String() string {
return fmt.Sprintf("%s-%04d", account.Owner, account.Number)
}
这是帐户为了接收付款而必须运行的功能/方法（我将付款实施为负金额的付款）：
func (account *Account) Listen(channel <-chan int) {
for amount := range channel {
account.Balance += amount
}
}
这是我的 Transfer 结构：
type Transfer struct {
Source *Account
Target *Account
Amount int
}
func NewTransfer(source *Account, target *Account, amount int) *Transfer {
transfer := Transfer{Source: source, Target: target, Amount: amount}
return &transfer
}
func (transfer Transfer) String() string {
return fmt.Sprintf("Transfer from [%s] to [%s] with amount CHF %4d.-",
transfer.Source, transfer.Target, transfer.Amount)
}
以下是通过通道向每个帐户执行一系列小额支付的函数/方法：
func (transfer Transfer) Execute(status chan<- string) {
const PAYMENT = 1
sourceChannel := make(chan int)
targetChannel := make(chan int)
go transfer.Source.Listen(sourceChannel)
go transfer.Target.Listen(targetChannel)
for paid := 0; paid < transfer.Amount; paid += PAYMENT {
sourceChannel <- -PAYMENT
targetChannel <- +PAYMENT
}
close(sourceChannel)
close(targetChannel)
status <- fmt.Sprintf("transfer done: %s", transfer)
}
最后，这是实际的程序：
func main() {
const ACCOUNTS = 25
const TRANSFERS = ACCOUNTS * 2
const AMOUNT = 5000
const BALANCE = 9000
fooStartBalance := 0
barStartBalance := 0
fooAccounts := [ACCOUNTS]*Account{}
barAccounts := [ACCOUNTS]*Account{}
for i := 0; i < ACCOUNTS; i++ {
fooAccounts[i] = NewAccount("foo", i + 1, BALANCE)
fooStartBalance += fooAccounts[i].Balance
barAccounts[i] = NewAccount("bar", i + 1, BALANCE)
barStartBalance += barAccounts[i].Balance
}
fooToBarTransfers := [ACCOUNTS]*Transfer{}
barToFooTransfers := [ACCOUNTS]*Transfer{}
for i := 0; i < ACCOUNTS; i++ {
fooToBarTransfers[i] = NewTransfer(fooAccounts[i], barAccounts[i], AMOUNT)
barToFooTransfers[i] = NewTransfer(barAccounts[i], fooAccounts[i], AMOUNT)
}
status := make(chan string)
for i := 0; i < ACCOUNTS; i++ {
go fooToBarTransfers[i].Execute(status)
go barToFooTransfers[i].Execute(status)
}
for i := 0; i < TRANSFERS; i++ {
fmt.Printf("%2d. %s\n", i + 1, <-status)
}
close(status)
fooEndBalance := 0
barEndBalance := 0
for i := 0; i < ACCOUNTS; i++ {
fooEndBalance += fooAccounts[i].Balance
barEndBalance += barAccounts[i].Balance
}
fmt.Printf("Start: foo: %4d, bar: %4d\n", fooStartBalance, fooStartBalance)
fmt.Printf(" End: foo: %4d, bar: %4d\n", fooEndBalance, fooEndBalance)
}
正如标准输出所示，所有传输都已在最后完成：
1. transfer done: Transfer from [bar-0011] to [foo-0011] with amount CHF 5000.-
[other 48 transfers omitted]
50. transfer done: Transfer from [bar-0013] to [foo-0013] with amount CHF 5000.-
但是金钱要么是创造出来的：
Start: foo: 225000, bar: 225000
End: foo: 225053, bar: 225053
或丢失：
Start: foo: 225000, bar: 225000
End: foo: 225053, bar: 225053
所以我认为（以我的 Java 思维方式）问题可能出在 Account.Listen() 上：也许 Goroutine A 读取了 Balance，然后是 Goroutine B，完全执行 Account.Listen()，然后 Goroutine A 继续执行旧值的计算。互斥锁可能会修复它：
type Account struct {
Owner string
Number int
Balance int
Mutex sync.Mutex
}
func (account *Account) Listen(channel <-chan int) {
for amount := range channel {
account.Mutex.Lock()
account.Balance += amount
account.Mutex.Unlock()
}
}
效果很好……十次中有九次。但后来：
Start: foo: 225000, bar: 225000
End: foo: 225001, bar: 225001
这很奇怪。互斥锁似乎有帮助，因为它大部分时间都在工作，而当它不起作用时，它只会关闭一个。我真的不知道其他地方同步可能是个问题。
更新：当我按如下方式实施帐户时，我无法防止数据竞争警告：
type Account struct {
sync.Mutex
Owner string
Number int
Balance int
}
func NewAccount(owner string, number int, balance int) *Account {
account := &Account{Owner: owner, Number: number, Balance: balance}
return account
}
func (account *Account) String() string {
return fmt.Sprintf("%s-%04d", account.Owner, account.Number)
}
func (account *Account) Listen(channel <-chan int) {
for amount := range channel {
account.Lock()
account.Balance += amount
account.Unlock()
}
}
func (account *Account) GetBalance() int {
account.Lock()
newBalance := account.Balance
defer account.Unlock()
return newBalance
}
我最后也像这样访问余额：
fooEndBalance += fooAccounts[i].GetBalance()
barEndBalance += barAccounts[i].GetBalance()
正如我所说，数据竞争检测器现在保持沉默，但我仍然在大约每 10 次运行时遇到一些错误：
Start: foo: 100000, bar: 100000
End: foo: 99999, bar: 99999
我真的不明白我做错了什么。
【问题讨论】：
标签： go concurrency goroutine