在C或PHP里面，文件锁会使用一个flock的函数去实现，其实Go里面也类似：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func main() {
    var f = "/var/logs/app.log"
    file, err := os.OpenFile(f, os.O_RDWR, os.ModeExclusive)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 调用系统调用加锁
    err = syscall.Flock(int(file.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        panic(err)
    }
    defer syscall.Flock(int(file.Fd()), syscall.LOCK_UN)
    // 读取文件内容
    all, err := ioutil.ReadAll(file)
    if err != nil {
        panic(err)
    }

    fmt.Printf("%s", all)
    time.Sleep(time.Second * 10) //模拟耗时操作
}

需要说明一下，Flock函数第一个参数是文件描述符，第二个参数是锁的类型，分为LOCK_EX（排它锁）、LOCK_SH（读共享锁）、LOCK_NB（遭遇锁的表现，遇到排它锁的时候默认会被阻塞，NB即非阻塞，直接返回Error）、LOCK_UN（解锁）。

如果这时候你打开另外一个终端再次运行这个程序你会发现报错信息如下：

1

panic: resource temporarily unavailable

文件锁保证了一个文件在操作系统层面的数据读写安全，不过实际应用中并不常见，毕竟大部分时候我们都是使用数据库去做数据存储，极少使用文件。

这是一个标准的互斥锁，平时用的也比较多，用法也非常简单，lock用于加锁，unlock用于解锁，配合defer使用，完美。

为了更好的展示锁的应用，这个举一个没有实际意义的例子,给一个int变量做加法，用2个协程并发的去做加法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

var i int

func main() {
    go add(&i)
    go add(&i)

    time.Sleep(time.Second * 3)

    println(i)
}

func add(i *int) {
    for j := 0; j < 10000; j++ {
        *i = *i + 1
    }
}

我们想要得到得正常结果是20000，然而实际上并不是，其结果是不固定的，很可能少于20000，大家多运行几次便可得知。

假设你多加一行 runtime.GOMAXPROCS(1)，你会发现结果一直是正确的，这是为什么呢？

用一个比较理论的说法，这是因为产生了数据竞争（data race）问题，在Go里面我们可以在go run后面加上 -race 来检测数据竞争，结果会告诉你在哪一行产生的，非常实用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

go run -race main.go
==================
WARNING: DATA RACE
Read at 0x00000056ccb8 by goroutine 7:
  main.add()
      main.go:23 +0x43
Previous write at 0x00000056ccb8 by goroutine 6:
  main.add()
       main.go:23 +0x59
Goroutine 7 (running) created at:
  main.main()
       main.go:14 +0x76
Goroutine 6 (running) created at:
  main.main()
       main.go:13 +0x52
==================
20000
Found 1 data race(s)
exit status 66

解决这个问题，有多种解法，我们当然可以换个写法，比如说用chan管道去做加法（chan底层也用了锁），实际上在Go里面更推荐去使用chan解决数据同步问题，而不是直接用锁机制。

在上面的这个例子里面我们需要在add方法里面写,每次操作之前lock，然后unlock：

1
2
3
4
5
6
7

func add(i *int) {
    for j := 0; j < 10000; j++ {
        s.Lock()
        *i = *i + 1
        s.Unlock()
    }
}

它的实现里面有5个方式：

1
2
3
4
5

func (rw *RWMutex) Lock()
func (rw *RWMutex) RLock()
func (rw *RWMutex) RLocker() Locker
func (rw *RWMutex) RUnlock()
func (rw *RWMutex) Unlock()

其中Lock()和Unlock()用于申请和释放写锁,RLock()和RUnlock()用于申请和释放读锁，RLocker()用于返回一个实现了Lock()和Unlock()方法的Locker接口。

实话说，平时这个用的真不多，主要是使用起来比较复杂，虽然在读性能上面比 Mutex 要好一点。

1
2
3
4

type User struct {
    m map[string]string
    l sync.Mutex
}

也就是一个map配一把锁的写法，可能是这种写法比较多，于是乎官方就在标准库里面实现了一个 sync.Map ,是一个自带锁的map，使用起来方便很多，省心。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var m sync.Map

func main() {
    m.Store("1", 1)
    m.Store("2", 1)
    m.Store("3", 1)
    m.Store(4, "5") // 注意类型

    load, ok := m.Load("1")
    if ok {
        fmt.Printf("%v\n", load)
    }

    load, ok = m.Load(4)
    if ok {
        fmt.Printf("%v\n", load)
    }
}

需要注意的一点是这个map的key和value都是interface{}类型，所以可以随意放入任何类型的数据，在使用的时候就需要做好断言处理。

执行结果只打印了一个 one，所以sync.Once的功能就是保证只执行一次，也算是一种锁，通常可以用于只能执行一次的初始化操作，比如说单例模式里面的懒汉模式可以用到。