update lesson23

Author: jincheng9

workspace/lesson19/goroutine7.go

@@ -18,7 +18,10 @@ func main() {
     /* wg跟踪10个goroutine */
     size := 10
     wg.Add(size)
-    /* 开启10个goroutine并发执行 */
+    /* 开启10个goroutine并发执行 
+    这里10个goroutine在闭包里都用了变量i，等闭包真正执行的时候，i的值
+    已经改变，所以这种实现方式不安全
+    */
     for i:=0; i<size; i++ {
         go func() {
             defer wg.Done()

workspace/lesson23/readme.md

@@ -1,12 +1,14 @@
-# sync.Mutex
+# sync.Mutex和sync.RWMutex
 
-## 定义
+## sync.Mutex
+
+### 定义
 
 Mutex是sync包里的一个结构体类型，含义就是互斥锁。Mutex变量的默认值或者说零值是一个没有加锁的mutex，也就是当前mutex的状态是unlocked。
 
 不要对Mutex使用值传递方式进行函数调用。
 
-Mutex允许一个goroutine对其加锁，其它goroutine对其解锁，不一定要加解锁在同一个goroutine里。
+Mutex允许一个goroutine对其加锁，其它goroutine对其解锁，不要求加锁和解锁在同一个goroutine里。
 
 Mutex结构体类型有2个方法
 
@@ -22,8 +24,6 @@ Mutex结构体类型有2个方法
   func (m *Mutex) Unlock()
   ```
 
-## 使用
-
 ### 不加锁
 
 * 场景举例：多个 goroutine对共享变量同时执行写操作，并发是不安全的，结果和预期不符。
@@ -104,4 +104,137 @@ Mutex结构体类型有2个方法
   }
   ```
 
-  
+
+
+
+## sync.RWMutex
+
+### 定义
+
+RWMutex是sync包里的一个结构体类型，含义是读写锁。RWMutex变量的零值是一个没有加锁的mutex。
+
+不要对RWMutex变量使用值传递的方式进行函数调用。
+
+RWMutex允许一个goroutine对其加锁，其它goroutine对其解锁，不要求加锁和解锁在同一个goroutine里。
+
+RWMutex结构体类型的定义如下：
+
+```go
+type RWMutex struct {
+    // some fields
+}
+```
+
+RWMutex结构体类型有5个方法：
+
+* Lock()，加写锁。某个goroutine加了写锁后，其它goroutine不能获取读锁，也不能获取写锁
+
+  ```go
+  func (rw *RWMutex) Lock()
+  ```
+
+* Unlock()，释放写锁。
+
+  ```go
+  func (rw *RWMutex) Unlock()
+  ```
+
+* RLock()，加读锁。某个goroutine加了读锁后，其它goroutine可以获取读锁，但是不能获取写锁
+
+  ```go
+  func (rw *RWMutex) RLock()
+  ```
+
+* RUnlock()，释放读锁
+
+  ```go
+  func (rw *RWMutex) RUnlock()
+  ```
+
+* RLocker()，获取一个类型为Locker的接口，Locker类型定义了Lock()和Unlock()方法
+
+  ```go
+  func (rw *RWMutex) RLocker() Locker
+  ```
+
+  类型Locker的定义如下
+
+  ```go
+  type Locker interface {
+      Lock()
+      Unlock()
+  }
+  ```
+
+  
+
+### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "sync"
+)
+
+type Counter struct {
+    /*
+    成员count:计数器
+    成员rw: 读写锁，用于实现count的读写并发安全
+    */
+    count int
+    rw sync.RWMutex
+}
+
+func (c *Counter) getCounter() int{
+    /*
+    读数据的时候加读锁
+    */
+    c.rw.RLock()
+    defer c.rw.RUnlock()
+    return c.count
+}
+
+func (c *Counter) add() {
+    /*
+    写数据的时候加写锁
+    */
+    c.rw.Lock()
+    defer c.rw.Unlock()
+    c.count++
+}
+
+func main() {
+    var wg sync.WaitGroup
+    size := 100
+    wg.Add(size)
+    
+    var c Counter
+    /*
+    开启size个goroutine对变量c的数据成员count同时进行读写操作
+    */
+    for i:=0; i<size; i++ {
+        go func() {
+            defer wg.Done()
+            c.getCounter()
+            c.add()
+        }()
+    }
+    wg.Wait()
+    fmt.Println("count=", c.count)
+}
+```
+
+
+
+## 注意事项
+
+* Mutex和RWMutex都不是递归锁，不可重入
+
+## References
+
+https://pkg.go.dev/[email protected]#Mutex
+
+https://pkg.go.dev/[email protected]#RWMutex
+

workspace/lesson23/rwmutex.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+    "fmt"
+    "sync"
+)
+
+type Counter struct {
+    /*
+    成员count:计数器
+    成员rw: 读写锁，用于实现count的读写并发安全
+    */
+    count int
+    rw sync.RWMutex
+}
+
+func (c *Counter) getCounter() int{
+    /*
+    读数据的时候加读锁
+    */
+    c.rw.RLock()
+    defer c.rw.RUnlock()
+    return c.count
+}
+
+func (c *Counter) add() {
+    /*
+    写数据的时候加写锁
+    */
+    c.rw.Lock()
+    defer c.rw.Unlock()
+    c.count++
+}
+
+func main() {
+    var wg sync.WaitGroup
+    size := 100
+    wg.Add(size)
+    
+    var c Counter
+    /*
+    开启size个goroutine对变量c的数据成员count同时进行读写操作
+    */
+    for i:=0; i<size; i++ {
+        go func() {
+            defer wg.Done()
+            c.getCounter()
+            c.add()
+        }()
+    }
+    wg.Wait()
+    fmt.Println("count=", c.count)
+}