Golang 共享内存

　　Golang语言中，进程间通信除了使用channel，还可以使用共享内存，即sync包。

Q-1

package main
import (
	"fmt"
	"time"
)
func main() {
	for i := 1; i < 6; i++ {
		go func(x int) {
			time.Sleep(time.Second)
			fmt.Println("第", x, "个子goroutine执行结束")
		}(i)
	}
	fmt.Println("主goroutine执行结束")
}

　　上面的代码毫无疑问的只会输出：“主goroutine执行结束”，而不会输出子goroutine执行结束，这是因为，主协程一旦执行完毕，整个进程就会结束。

　　

sync组等待

　　sync包中常用的有三个方法：Add(num int) 、 Done()、 Wait()

　　sync中会在内部维持一个类似于计数器的东西，通过Add方法来增加计数器的值，增加参数num；通过Done来减少计数器的值，一次只能减少1；Wait方法会使主协程阻塞，只有到内部计数器的值为0时，阻塞才会解开。

　　用法如下：

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	var wg sync.WaitGroup
	for i := 1; i < 6; i++ {
		wg.Add(1) //计数器加1
		go func(x int) {
			time.Sleep(time.Second)
			fmt.Println("第", x, "个子goroutine执行结束")
			wg.Done() //goroutine执行完毕，计数器减1
		}(i)
	}
	wg.Wait()  // 计数器不为0的时候，一直阻塞；计数器变为0的时候，阻塞解开
	fmt.Println("主goroutine执行结束")
}

　　注意：添加的计时器数量必须比减少计时器的数量要少，否则会引发死锁。

　　比如，将计数器值增加了10，但是只执行了9次计数器减少，剩余一个计数器，计数器的值始终不为0，则主协程一直等待，形成死锁。但是较少计数器的次数可以比计数器的值要大，可以提前结束主协程的阻塞。

　　

Q-2

　　请看下面一段代码，尝试在两个循环中，各自使sum加1，执行1000次，乍一看，觉得结果是sum的最终结果是2000，但是真正执行之后，结果不是2000。

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	wg.Add(2)
	var sum int = 0
	go func() {
		for i := 0; i < 1000; i++ {
			sum++
		}
		wg.Done()
	}()
	go func() {
		for i := 0; i < 1000; i++ {
			sum++
		}
		wg.Done()
	}()

	wg.Wait()
	fmt.Println(sum)
}

　　

sync互斥锁

　　sync互斥锁有两个常用的方法，Lock()加锁，Unlock()解锁。使用Lock加锁后，不能再进行加锁，只有当对其进行Unlock解锁之后，才能对其加锁。这个很好理解。

　　如果对一个未加锁的资源进行解锁，会引发panic异常。

　　可以在一个goroutine中对一个资源加锁，而在另外一个goroutine中对该资源进行解锁。

　　使用示例如下：

package main
import (
	"fmt"
	"sync"
)
func main() {
	var wg sync.WaitGroup
	var mutex sync.Mutex
	wg.Add(2)
	var sum int = 0
	go func() {
		for i := 0; i < 1000; i++ {
			mutex.Lock() //上锁
			sum++
			mutex.Unlock()//解锁
		}
		wg.Done()
	}()
	go func() {
		for i := 0; i < 1000; i++ {
			mutex.Lock() //加锁
			sum++
			mutex.Unlock() //解锁
		}
		wg.Done()
	}()

	wg.Wait()
	fmt.Println(sum)
}

　　

sync读写互斥锁（多读单写锁）

　　允许对同一资源进行同时读，但是不能进行同时写，也不能进行一边读，一边写。

　　如果一个资源被加了写锁，那么就不能再给他加其他锁，包括写锁，只能等写锁解开后，才能继续加其他锁。如果一个资源被加了读锁，那么，仍然可以给该资源加读锁，但是不能加写锁，必须等读锁释放后，才能加写锁。

　　sync.RWMutex有四个常用的方法：

　　　　Lock()加写锁  、 Unlock()取消写锁 、 RLock()加读锁 、 RUnlock()释放读锁

　　使用示例：

package main

import (
	"fmt"
	"sync"
	"time"
)

var rwMutex sync.RWMutex //定义一个读写互斥锁

//注意传递的组等待是指针形式
func WriteData(wg *sync.WaitGroup, id int) {
	rwMutex.Lock() //加 写锁
	fmt.Println("增加第", id, "个写锁")
	for i := 0; i < 5; i++ {
		fmt.Println("进行写操作")
		time.Sleep(time.Second)
	}
	fmt.Println("释放第", id, "个写锁")
	rwMutex.Unlock() //释放 写锁
	wg.Done()
}

func ReadData(wg *sync.WaitGroup, id int) {
	rwMutex.RLock() //加 读锁
	fmt.Println("增加第", id, "个读锁")
	for i := 0; i < 5; i++ {
		fmt.Println("进行读操作")
		time.Sleep(time.Second)
	}
	fmt.Println("释放第", id, "个读锁")
	rwMutex.RUnlock() //释放 读锁
	wg.Done()
}

func main() {
	var wg sync.WaitGroup
	for i := 1; i < 3; i++ {
		wg.Add(1)
		go WriteData(&wg, i)
	}
	for i := 1; i < 4; i++ {
		wg.Add(1)
		go ReadData(&wg, i)
	}

	wg.Wait()
	fmt.Println("主程序执行完毕")
}

　　运行之后，就会发现，只有一个写加锁，只有写解锁之后，才允许加其他锁；如果是加读锁之后，可以再加读锁。

 

Q-3

package main

import (
	"fmt"
	"sync"
)

func demo() {
	fmt.Println("运行demo函数")
}

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			demo()
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println("主程序结束")
}

　　这个示例代码运行之后，会输出10次“运行demo函数”，因为有10个goroutine，每个goroutine都运行了1次。

　　现在的需求是：虽然有10个goroutine，但是希望只有一个goroutine中执行demo函数，如果一个goroutine执行过了demo函数，其他的goroutine就会忽略demo函数，不去执行demo，保证demo函数只被执行一次。

 

sync.once初始化

　　sync.Once就是用来解决上面这个问题的：Once的作用就是多次调用，但只执行一次，Once只有一个方法->Once.Do(func)，向Do中传入一个函数，在第一次执行Once.Do()的时候，才执行传入的func，以后在执行Once.Do()，就不会再执行传入的func。

　　示例如下：

package main

import (
	"fmt"
	"sync"
)

func demo() {
	fmt.Println("运行demo函数")
}

func main() {
	var wg sync.WaitGroup
	var once sync.Once
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			once.Do(demo)
			//注意不要写成once.Do(demo()),这样写是把demo()的运行结果传入Do
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println("主程序结束")
}

　　这样就不会执行多次demo()，而只输出一次“运行demo函数”