go语言在云计算时代将会如日中天，还抱着.NET不放的人将会被淘汰。学习go语言和.NET完全不一样，它有非常简单的runtime 和 类库。最好的办法就是将整个源代码读一遍，这是我见过最简洁的系统类库。读了之后，你会真正体会到C#的面向对象的表达方式是有问题的，继承并不是必要的东西。相同的问题，在go中有更加简单的表达。
go runtime 没有提供任何的锁，只是提供了一个PV操作原语。独占锁，条件锁 都是基于这个原语实现的。如果你学习了go，那就就知道如何在windows下高效的方式实现条件锁定（windows没有自带的条件锁）。
我想阅读源代码，不能仅仅只看到实现了什么，还要看到作者的设计思路，还有如果你作为作者，如何实现。这些才是真正有用的东西，知识永远学不完，我们要锻炼我们的思维。
要写这篇文章的背景就忽略吧，我已经很久没有写博客了，主要原因是我基本上看不到能让我有所帮助的博客，更多的是我认为我也写不出能对别人有所帮助的文章。为了写这篇文章，我还是花了挺多的心思收集历史资料， 论坛讨论，并去golang-nuts 上咨询了一些问题。希望对大家有所帮助。
一. sync.Mutex 是什么？
Mutex是一种独占锁，一般操作系统都会提供这种锁。但是，操作系统的锁是针对线程的，golang里面没有线程的概念，这样操作系统的锁就用不上了。所以，你看go语言的runtime，就会发现，实际上这是一个“操作系统”。如果Mutex还不知道的话，我建议看下面的文章，其中第一篇必看。
百度百科 mutex http://baike.baidu.com/view/1461738.htm?fromId=1889552&redirected=seachword
信号量：http://swtch.com/semaphore.pdf
还可以读一下百度百科 pv 操作：http://baike.baidu.com/view/703687.htm
二. golang 最新版本的 sync.Mutex
你可以大致扫描一下最新版本的实现，如果你第一眼就看的很懂了，每步的操作？为什么这样操作？有没有更加合理的操作？那恭喜你，你的水平已经超过google实现 sync.Mutex 的程序员了，甚至是大部分的程序员，因为这个程序历经几年的演化，才到了今天的样子，你第一眼就能看的如此透彻，那真的是很了不起。下面的章节是为没有看懂的人准备的。
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package sync provides basic synchronization primitives such as mutual
// exclusion locks. Other than the Once and WaitGroup types, most are intended
// for use by low-level library routines. Higher-level synchronization is
// better done via channels and communication.
//
// Values containing the types defined in this package should not be copied.
package sync
import (
"sync/atomic"
"unsafe"
)
// A Mutex is a mutual exclusion lock.
// Mutexes can be created as part of other structures;
// the zero value for a Mutex is an unlocked mutex.
type Mutex struct {
state int32
sema uint32
}
// A Locker represents an object that can be locked and unlocked.
type Locker interface {
Lock()
Unlock()
}
const (
mutexLocked = 1 << iota // mutex is locked
mutexWoken
mutexWaiterShift = iota
)
// Lock locks m.
// If the lock is already in use, the calling goroutine
// blocks until the mutex is available.
func (m *Mutex) Lock() {
// Fast path: grab unlocked mutex.
if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
if raceenabled {
raceAcquire(unsafe.Pointer(m))
}
return
}
awoke := false
for {
old := m.state
new := old | mutexLocked
if old&mutexLocked != 0 {
new = old + 1<<mutexWaiterShift
}
if awoke {
// The goroutine has been woken from sleep,
// so we need to reset the flag in either case.
new &^= mutexWoken
}
if atomic.CompareAndSwapInt32(&m.state, old, new) {
if old&mutexLocked == 0 {
break
}
runtime_Semacquire(&m.sema)
awoke = true
}
}
if raceenabled {
raceAcquire(unsafe.Pointer(m))
}
}
// Unlock unlocks m.
// It is a run-time error if m is not locked on entry to Unlock.
//
// A locked Mutex is not associated with a particular goroutine.
// It is allowed for one goroutine to lock a Mutex and then
// arrange for another goroutine to unlock it.
func (m *Mutex) Unlock() {
if raceenabled {
_ = m.state
raceRelease(unsafe.Pointer(m))
}
// Fast path: drop lock bit.
new := atomic.AddInt32(&m.state, -mutexLocked)
if (new+mutexLocked)&mutexLocked == 0 {
panic("sync: unlock of unlocked mutex")
}
old := new
for {
// If there are no waiters or a goroutine has already
// been woken or grabbed the lock, no need to wake anyone.
if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
return
}
// Grab the right to wake someone.
new = (old - 1<<mutexWaiterShift) | mutexWoken
if atomic.CompareAndSwapInt32(&m.state, old, new) {
runtime_Semrelease(&m.sema)
return
}
old = m.state
}
}
三. 有没有更加简洁的实现方法？
有点操作系统知识的都知道，独占锁是一种特殊的PV 操作，就 0 – 1 PV操作。那我想，如果不考虑任何性能问题的话，用信号量应该就可以这样实现Mutex：
type Mutex struct {
sema uint32
}
func NewMutex() *Mutex {
var mu Mutex
mu.sema = 1
return &mu
}
func (m *Mutex) Lock() {
runtime_Semacquire(&m.sema)
}
func (m *Mutex2) Unlock() {
runtime_Semrelease(&m.sema)
}
当然，这个实现有点不符合要求。如果有个家伙不那么靠谱，加锁了一次，但是解锁了两次。第二次解锁的时候，应该报出一个错误，而不是让错误隐藏。于是乎，我们想到用一个变量表示加锁的次数。这样就可以判断有没有多次解锁。于是乎，我就想到了下面的解决方案：
type Mutex struct {这个解决方案除了解决了我们前面说的重复加锁的问题外，还对我们初始化工作做了简化，不需要构造函数了。注意，这也是golang里面一个常见的设计模式，叫做 零初始化。
key int32
sema uint32
}
func (m *Mutex) Lock() {
if atomic.AddInt32(&m.key, 1) == 1 {
// changed from 0 to 1; we hold lock
return
}
runtime_Semacquire(&m.sema)
}
func (m *Mutex) Unlock() {
switch v := atomic.AddInt32(&m.key, -1); {
case v == 0:
// changed from 1 to 0; no contention
return
case v == -1:
// changed from 0 to -1: wasn't locked
// (or there are 4 billion goroutines waiting)
panic("sync: unlock of unlocked mutex")
}
runtime_Semrelease(&m.sema)
}
理解一个程序如何工作很简单，但是，作者的设计思路才是关键，我们可以不断的看源代码，看别人的实现，我们能从中学到很多知识与技巧，当遇到相同的问题的时候，我们也能解决类似的问题。
我个人觉得，作为一个天朝的程序员，不能仅仅是山寨别人的软件，学习别人的东西。还是要能进入一个新的领域，一个未知的领域，还能有所创新。
当然，作者的设计思路我们很难得知，我们看到的只是劳动的结果，但是，我们可以这样问自己，如果我是作者，我怎么思考这个问题，然后解决这个问题。我发现，用这样的思维去考虑问题，有时候能给我很多的启示。
还有五分钟就12点了，我必须睡觉了，今天也只能先回答半个问题了。至于为什么不是一个问题，而是半个问题，请听下回分解。
有疑问加站长微信联系（非本文作者）
