第三节 Begin()实现

此处需要说明一下：在boltdb中，事务的开启方法是绑定在DB对象上的，为了保证内容的完整性，我们还是把事务开启的Begin()方法补充到这个地方。

前面提到boltdb中事务分为两类，它的区分就是在开启事务时，根据传递的参数来内部执行不同的逻辑。

在读写事务中，开始事务时加锁，也就是db.rwlock.Lock()。在事务提交或者回滚时才释放锁:db.rwlock.UnLock()。同时也印证了我们前面说的，同一时刻只能有一个读写事务在执行。

1. // Begin starts a new transaction.
2. // Multiple read-only transactions can be used concurrently but only one
3. // write transaction can be used at a time. Starting multiple write transactions
4. // will cause the calls to block and be serialized until the current write
5. // transaction finishes.
6. //
7. // Transactions should not be dependent on one another. Opening a read
8. // transaction and a write transaction in the same goroutine can cause the
9. // writer to deadlock because the database periodically needs to re-mmap itself
10. // as it grows and it cannot do that while a read transaction is open.
11. //
12. // If a long running read transaction (for example, a snapshot transaction) is
13. // needed, you might want to set DB.InitialMmapSize to a large enough value
14. // to avoid potential blocking of write transaction.
15. //
16. // IMPORTANT: You must close read-only transactions after you are finished or
17. // else the database will not reclaim old pages.
18. func (db *DB) Begin(writable bool) (*Tx, error) {
19. if writable {
20. return db.beginRWTx()
21. }
22. return db.beginTx()
23. }

25. func (db *DB) beginTx() (*Tx, error) {
26. // Lock the meta pages while we initialize the transaction. We obtain
27. // the meta lock before the mmap lock because that's the order that the
28. // write transaction will obtain them.
29. db.metalock.Lock()

31. // Obtain a read-only lock on the mmap. When the mmap is remapped it will
32. // obtain a write lock so all transactions must finish before it can be
33. // remapped.
34. db.mmaplock.RLock()

36. // Exit if the database is not open yet.
37. if !db.opened {
38. db.mmaplock.RUnlock()
39. db.metalock.Unlock()
40. return nil, ErrDatabaseNotOpen
41. }

43. // Create a transaction associated with the database.
44. t := &Tx{}
45. t.init(db)

47. // Keep track of transaction until it closes.
48. db.txs = append(db.txs, t)
49. n := len(db.txs)

51. // Unlock the meta pages.
52. db.metalock.Unlock()

54. // Update the transaction stats.
55. db.statlock.Lock()
56. db.stats.TxN++
57. db.stats.OpenTxN = n
58. db.statlock.Unlock()

60. return t, nil
61. }

63. func (db *DB) beginRWTx() (*Tx, error) {
64. // If the database was opened with Options.ReadOnly, return an error.
65. if db.readOnly {
66. return nil, ErrDatabaseReadOnly
67. }

69. // Obtain writer lock. This is released by the transaction when it closes.
70. // This enforces only one writer transaction at a time.
71. db.rwlock.Lock()

73. // Once we have the writer lock then we can lock the meta pages so that
74. // we can set up the transaction.
75. db.metalock.Lock()
76. defer db.metalock.Unlock()

78. // Exit if the database is not open yet.
79. if !db.opened {
80. db.rwlock.Unlock()
81. return nil, ErrDatabaseNotOpen
82. }

84. // Create a transaction associated with the database.
85. t := &Tx{writable: true}
86. t.init(db)
87. db.rwtx = t

89. // Free any pages associated with closed read-only transactions.
90. var minid txid = 0xFFFFFFFFFFFFFFFF
91. // 找到最小的事务id
92. for _, t := range db.txs {
93. if t.meta.txid < minid {
94. minid = t.meta.txid
95. }
96. }
97. if minid > 0 {
98. // 将之前事务关联的page全部释放了，因为在只读事务中，没法释放，只读事务的页，因为可能当前的事务已经完成 ，但实际上其他的读事务还在用
99. db.freelist.release(minid - 1)
100. }

102. return t, nil
103. }