golang锁

golang锁包：https://studygolang.com/pkgdoc

sync.Mutex是一个互斥锁

var lock sync.Mutex

加锁段在中

lock.lock()

lock.unlock()

sync.RWMutex为读写锁。使用方法同互斥锁

package main

import (
	"fmt"
)

func main() {
	var a = 1

	go func(num *int) {
		for n := 0; n < 1000; n++ {
			*num++
		}
	}(&a)

	go func(num1 *int) {
		for i := 0; i < 1000; i++ {
			*num1++
		}
	}(&a)

	fmt.Println(a)
}

发现执行结果输出为1，原因为主进程在创建完子线程后就结束了。子线程还未执行。也就没有对变量a进程运算

使用sync.WaitGroup等待子线程结束后退出。

package main

import (
	"fmt"
	"sync"
)

func main() {
	var a int
	var wg sync.WaitGroup
	wg.Add(2)
	go func(num *int) {
		for n := 0; n < 100000; n++ {
			*num++
		}
		wg.Done()
	}(&a)

	go func(num1 *int) {
		for i := 0; i < 100000; i++ {
			*num1++

		}
		wg.Done()
	}(&a)
	wg.Wait()
	fmt.Println(a)
}

在运行多次后发现并不等于200000，而且每次都不同，原因为线程1在操作a变量时变量为0，运算的1，在运算过程中，线程b也读取a变量此时a还为1，也就造就了运算结果不一致问题。

此时就需要使用锁，sync.Mutex

package main

import (
	"fmt"
	"sync"
)

func main() {
	var a int
	var wg sync.WaitGroup
	var lock sync.Mutex
	wg.Add(2)
	go func(num *int) {
		for n := 0; n < 100000; n++ {
			lock.Lock()
			*num++
			lock.Unlock()
		}
		wg.Done()
	}(&a)

	go func(num1 *int) {
		for i := 0; i < 100000; i++ {
			lock.Lock()
			*num1++
			lock.Unlock()
		}
		wg.Done()
	}(&a)
	wg.Wait()
	fmt.Println(a)
}

执行多次后结果都是唯一的。

数据竞争

func RWlock() {
	var a int

	go func(num *int) {
		for n := 0; n < 100000; n++ {
			*num++
		}
	}(&a)
	fmt.Println("------", a)
}

func main() {
	RWlock()
}

编译后执行，提示wirte 线程goroutine 6 与读进程 goroutine main有数据冲突

C:\Users\LC>C:\Users\LC\lock2.exe
------ 0
==================
WARNING: DATA RACE
Write at 0x00c000058058 by goroutine 6:
  main.RWlock.func1()
      D:/go_work/src/lock/lock2/lock1.go:14 +0x72

Previous read at 0x00c000058058 by main goroutine:
  main.RWlock()
      D:/go_work/src/lock/lock2/lock1.go:19 +0xd1
  main.main()
      D:/go_work/src/lock/lock2/lock1.go:23 +0x36

Goroutine 6 (running) created at:
  main.RWlock()
      D:/go_work/src/lock/lock2/lock1.go:11 +0xc3
  main.main()
      D:/go_work/src/lock/lock2/lock1.go:23 +0x36
==================
Found 1 data race(s)

在读的地方也加上锁后

lock.Lock()
fmt.Println("------", a)
lock.Unlock()

C:\Users\LC>go build -race lock\lock2

C:\Users\LC>C:\Users\LC\lock2.exe
------ 0

读写锁

读只对共享资源进行读操作，写只对共享资源进行写操作，使用场景，在读多写少时，加互斥锁性能较低，第一个读进行操作时，第二个读进程在等待，他们之间互斥。此时加上读写锁后，第一个线程加上读锁时，后面的资源都可以进行操作。

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
)

func rwLock() {
	var counts uint32
	var lock sync.Mutex
	// var lock sync.RWMutex
	var num int
	for n := 0; n < 3; n++ { //创建3个写线程
		go func(number *int) {
			lock.Lock()
			*number++
			time.Sleep(10 * time.Millisecond)
			lock.Unlock()
		}(&num)
	}
	for n := 0; n < 100; n++ { //创建100个读线程
		go func(number *int) {
			for { //每个线程死循环无限读，
				// lock.RLock()
				lock.Lock()
				// fmt.Println(*number)
				time.Sleep(time.Millisecond * 3)
				lock.Unlock()
				// lock.RUnlock()
				atomic.AddUint32(&counts, 1) //记录读的次数
			}
		}(&num)
	}

	time.Sleep(time.Second * 3) //主进程总共执行时间3秒，即3秒内互斥锁和读写锁在读方面可执行多少次
	fmt.Println(atomic.LoadUint32(&counts)) //获取读的总次数
}

func main() {
	rwLock()
}

将读写锁改为互斥锁后，本次测试的次数相差很多