方法一（对数据库的读写操作加锁）

一（DAO层加行锁:读写锁）

package main

import (
    "sync"
)
//1、多个读之间不存在互斥关系
//2、写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的
type idMutex map[string] *sync.RWMutex

var myIdMutex idMutex
func init() {
    myIdMutex=make(map[string] *sync.RWMutex)
}
//读锁定
func (this *idMutex)RLock(id string){
    m,ok:=(*this)[id]
    if !ok {
        m=new(sync.RWMutex)
        (*this)[id]=m
    }
    m.RLock()
}
//读解锁
func (this *idMutex)RUnlock(id string){
    m,ok:=(*this)[id]
    if !ok {
        return
    }
    m.RUnlock()
}
//写操作锁定
func (this *idMutex)Lock(id string){
    m,ok:=(*this)[id]
    if !ok {
        m=new(sync.RWMutex)
        (*this)[id]=m
    }
    m.Lock() //写操作锁定
}
//写操作解锁
func (this *idMutex)Unlock(id string) {
    m,ok:=(*this)[id]
    if !ok {
        return
    }
    m.Unlock()//写操作解锁
}
type Accout struct {
    Id string
}
//进行读的操作
func (this *Accout) Reed() {
    myIdMutex.RLock(this.Id)
    defer myIdMutex.RUnlock(this.Id)
}
//进行写的操作
func (this *Accout) Write() {
    myIdMutex.Lock(this.Id) //写操作锁定
    defer myIdMutex.Unlock(this.Id)  //写操作解锁
}
func main() {
    acout:=Accout{Id:"798456"}
    acout.Reed()
    acout.Write()
}

一（对象加锁） 将读写的方法封装，并且添加锁

type Accout struct {
    flag sync.Mutex            //sync.Mutex类型
}
//进行读的操作
func (a *Accout) Reed(n int) {  //读
    a.flag.Lock()            //锁上
    defer a.flag.Unlock()    //在方法运行完之后解开
}
//进行写的操作
func (a *Accout) Write(n int) {  //读
    a.flag.Lock()            //锁上
    defer a.flag.Unlock()    //在方法运行完之后解开
}

方法二（直接对数据库进行操作）

原理

数据库使用InnoDB

　　 InnoDB与MyISAM的最大不同有两点：一是支持事务（TRANSACTION）；二是采用了行级锁。

　　 InnoDB实现了以下两种类型的行锁。

• 共享锁（s）：允许一个事务去读一行，阻止其他事务获得相同数据集的排他锁。
• 排他锁（Ｘ）：允许获取排他锁的事务更新数据，阻止其他事务取得相同的数据集共享读锁和排他写锁。
  另外，为了允许行锁和表锁共存，实现多粒度锁机制，InnoDB还有两种内部使用的意向锁（Intention Locks），这两种意向锁都是表锁。
• 意向共享锁（IS）：事务打算给数据行共享锁，事务在给一个数据行加共享锁前必须先取得该表的IS锁。
• 意向排他锁（IX）：事务打算给数据行加排他锁，事务在给一个数据行加排他锁前必须先取得该表的IX锁。

　　 如果一个事务请求的锁模式与当前的锁兼容，InnoDB就请求的锁授予该事务；反之，如果两者两者不兼容，该事务就要等待锁释放。

　　 意向锁是InnoDB自动加的，不需用户干预。对于UPDATE、DELETE和INSERT语句，InnoDB会自动给涉及及数据集加排他锁（Ｘ）（允许获取排它锁的事物进行操作，其他事物处于阻塞状态）；对于普通SELECT语句，InnoDB不会任何锁；事务可以通过以下语句显示给记录集加共享锁或排锁。

共享锁（Ｓ）：SELECT * FROM table_name WHERE ... LOCK IN SHARE MODE
排他锁（X）：SELECT * FROM table_name WHERE ... FOR UPDATE

代码

package main
import(
    "database/sql"
    _"github.com/go-sql-driver/mysql"
    "log"
    "time"
    "math/rand"
)
// 连接池大小
var MAX_POOL_SIZE = 20
var dbPoll chan *sql.DB

const (
    user="root"
    pass="root"
    db="school"

)
func putDB(db *sql.DB) {
    // 基于函数和接口间互不信任原则，这里再判断一次，养成这个好习惯哦
    if dbPoll == nil {
        dbPoll = make(chan *sql.DB, MAX_POOL_SIZE)
    }
    if len(dbPoll) >= MAX_POOL_SIZE {
        db.Close()
        return
    }
    dbPoll <- db
}
func initDB() {
    // 缓冲机制，相当于消息队列
    if len(dbPoll) == 0 {
        // 如果长度为0，就定义一个redis.Conn类型长度为MAX_POOL_SIZE的channel
        dbPoll = make(chan *sql.DB, MAX_POOL_SIZE)
        go func() {
            for i := 0; i < MAX_POOL_SIZE/2; i++ {
                db,err:=sql.Open("mysql",user+":"+pass+"@tcp(localhost:3306)/"+db+"?charset=utf8")
                if err!=nil {
                    log.Println(err)
                }
                putDB(db)
            }
        } ()
    }
}
func GetDB()  *sql.DB {
    //如果为空就初始化或者长度为零
    if dbPoll == nil||len(dbPoll) == 0{
        initDB()
    }
    return <- dbPoll
}
func main(){
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i:=0;i<10 ;i++  {
        go changeCount(r.Intn(50))
        go changeCount(r.Intn(50))
        go changeCount(r.Intn(50))
        go changeCount(r.Intn(50))
    }
    time.Sleep(3*time.Second)
}
func changeCount(num int )  {
    db:=GetDB()
    tx, err := db.Begin()//打开事物
    defer tx.Commit()//事物提交
    //意向共享锁（IS）：事务打算给数据行共享锁，事务在给一个数据行加共享锁前必须先取得该表的IS锁。
    //意向排他锁（IX）：事务打算给数据行加排他锁，事务在给一个数据行加排他锁前必须先取得该表的IX锁。
    //意向锁是InnoDB自动加的，不需用户干预。
    res,_ := tx.Exec("UPDATE product  set count=count-? WHERE Id=1 AND count>=?  ",num,num)
    RowsAffected, err := res.RowsAffected()
    if err != nil {
        log.Println("res.RowsAffected==================Err")
    }
    if RowsAffected>0 {
        addToOrder()
        log.Println(time.Now(),"抢购成功==================",num)
    }else {
        log.Println(time.Now(),"抢购失败==================",num)
    }
}
//添加到订单等操作
func addToOrder()  {

}

方法三（中间使用redis进行缓存）

原理可以参考奔跑的Man这篇博客
或者我复制他的Redis多并发问题

import (
    "github.com/garyburd/redigo/redis"
    "fmt"
    "time"
    "strconv"
    "runtime"
)

var Address = "127.0.0.1:6379"
var Network = "tcp"
func GetRedis()  redis.Conn  {
    c, err := redis.Dial(Network, Address)
    if err != nil {
        return GetRedis()
    }
    return c
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    for i:=0;i<100;i++  {
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
        go do()
    }
    time.Sleep(time.Second*60*10)
}
func do()  {
    cnn:=GetRedis()
    defer   cnn.Close()
    redisLock("lock.foo",cnn,20,doFunc,"致远")

}
//lockKey锁的名称
//cnn       redis.Conn
//deadTime      锁默认消亡时间
//doFunc        参数名称
//param     方法参数
func redisLock(lockKey string,cnn redis.Conn,deadTime int,doFunc func(interface{}),param interface{})  {
    setnxTime:=time.Now().UTC().UnixNano()
    ex,err:=cnn.Do("SETNX",lockKey,setnxTime+int64(deadTime))
    if err==nil {
        if ex==int64(0) {
            //fmt.Println("存在锁:下来判断锁是否过期了")
            lock2,err:=cnn.Do("GET",lockKey)
            if lock2==nil {
                //fmt.Println("lock2=======为空ex",ex,ex==int64(0))
                redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                return
            }
            if err!=nil {
                redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                return
            }
            getTime, err :=strconv.ParseInt(string(lock2.([]uint8)), 10, 64)
            if getTime>setnxTime {
                //锁未过期
                //fmt.Println("锁没有过期：继续等吧")
                redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                return
            }else {
                //锁已经过期
                time.Sleep(time.Millisecond*time.Duration(deadTime))//线程休眠
                getsettime:=time.Now().UTC().UnixNano()
                lock3,err:=cnn.Do("GETSET",lockKey,getsettime)
                if lock3==nil {
                    //fmt.Println("lock3=======为空")
                    redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                    return
                }
                getSetTime, err :=strconv.ParseInt(string(lock3.([]uint8)), 10, 64)
                if err!=nil {
                    //fmt.Println("出问题了：去继续等吧")
                    redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                    return
                }
                if getSetTime==getTime {//如果更改前的时间和已经过期的时间相同
                    //获得锁直接操作数据
                    //fmt.Println("锁过期：处理了死锁，可以直接操作数据")
                    doFunc(param)
                    cnn.Do("DEL",lockKey)//删除锁
                    return
                }else{//更改前的时间和已经过期的时间不同
                    //fmt.Println("判断后：没有死锁，继续等吧")
                    redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
                    return
                }
            }
        }else{
            //fmt.Println("不存在锁：可以操作数据")
            doFunc(param)
            cnn.Do("DEL",lockKey)//删除锁
            return
        }
    }else {
        redisLock(lockKey ,cnn ,deadTime ,doFunc ,param )
        return
    }
}
var count=0
func doFunc(str interface{})  {
    count+=1
    fmt.Println("操作数据中.............============================",count,str)
    return
}