func TestMustGoRun2(ot *testing.T){
    kmgFile.MustDelete("testFile")
    defer kmgFile.MustDelete("testFile")
    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgLibA/a.go",[]byte(`package pkgLibA

func A() string{
    return "A"
}
`))
    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgMainA/a.go",[]byte(`package main
import(
    "pkgLibA"
    "fmt"
)
func main(){
    fmt.Println(pkgLibA.A())
}
`))
    testerWithPkg :=func() []byte{
        p:=MustNewProgramV2(map[string]string{"GOPATH":kmgFile.MustGetFullPath("testFile")},"pkgMainA")
        buf:=bytes.Buffer{}
        p.mustGoRun(nil,func(cmdSlice []string,env map[string]string){
            b:=kmgCmd.CmdSlice(cmdSlice).
            MustSetEnvMap(env).
            MustRunAndReturnOutput()
            buf.Write(b)
        })
        return buf.Bytes()
    }
    testerWithPath :=func() []byte{
        p:=MustNewProgramV2(map[string]string{"GOPATH":kmgFile.MustGetFullPath("testFile")},"testFile/src/pkgMainA/a.go")
        buf:=bytes.Buffer{}
        p.mustGoRun(nil,func(cmdSlice []string,env map[string]string){
            b:=kmgCmd.CmdSlice(cmdSlice).
            MustSetEnvMap(env).
            MustRunAndReturnOutput()
            buf.Write(b)
        })
        return buf.Bytes()
    }
    kmgTest.Equal(string(testerWithPkg()),"A\n")

    kmgFile.MustDelete("testFile/pkg")
    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgLibA/a.go",[]byte(`package pkgLibA

func A() string{
    return "B"
}
`))
    kmgTest.Equal(string(testerWithPkg()),"B\n")

    now:=time.Now()
    time.Sleep(now.Round(time.Second).Add(time.Second).Sub(now))
    // 已知的golang的pkg的缓存bug.(1秒钟后会问题自然解决.)
    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgLibA/a.go",[]byte(`package pkgLibA

func A() string{
    return "C"
}
`))
    kmgTest.Equal(string(testerWithPkg()),"C\n")
    kmgTest.Equal(string(testerWithPath()),"C\n")

    now=time.Now()
    time.Sleep(now.Round(time.Second).Add(time.Second).Sub(now))
    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgLibA/a.go",[]byte(`package pkgLibA

func A() string{
    return "D"
}
`))
    kmgTest.Equal(string(testerWithPath()),"D\n")

    kmgFile.MustWriteFileWithMkdir("testFile/src/pkgMainA/a.go",[]byte(`package main
import(
    "pkgLibA"
    "fmt"
)
func main(){
    fmt.Println(pkgLibA.A(),"A")
}
`))
    kmgTest.Equal(string(testerWithPath()),"D A\n")
    kmgTest.Equal(string(testerWithPkg()),"D A\n")
}

    now=time.Now()
    time.Sleep(now.Round(time.Second).Add(time.Second).Sub(now))

package kmgCache
import (
    "time"
    "sync"
    "github.com/bronze1man/kmg/encoding/kmgGob"
    "os"
    "crypto/md5"
    "io"
    "encoding/hex"
    "github.com/bronze1man/kmg/kmgFile"
)

// 使用文件绝对路径获取md5,如果文件不存在,会返回 ""
type FileMd5Getter struct{
    imp *fileMd5GetterImp
}
func (getter FileMd5Getter) GetMd5ByFullPath(path string) string{
    return getter.imp.getMd5ByFullPath__NOLOCK(path)
}
func (getter FileMd5Getter) GetMd5ByStatAndFullPath(statAndFullPath kmgFile.StatAndFullPath) string{
    return getter.imp.getMd5ByStatAndFullPath__NOLOCK(statAndFullPath)
}
type FileMd5GetByFullPath func(path string) string

// 使用缓存方法获取某个文件的md5.
// 由于有各种锁的存在,请不要嵌套使用该函数.
// 此函数在保证正确性的前提下,尽最大努力提高性能.
// 同一个数据库文件,在同一时间只能有一个cb运行.
// 请传入文件绝对路径,避免使用相对路径,减少当前目录的干扰.
func FileMd5Get(dbFilePath string,cb func(getter FileMd5Getter)) {
    getterImp :=getFileMd5GetterByDbFilePath(dbFilePath)
    getterImp.locker.Lock()
    getterImp.cacheNow = time.Now()
    getterImp.hasChange = false
    outGetter:=FileMd5Getter{imp: getterImp}
    cb(outGetter)
    if getterImp.hasChange{
        kmgGob.MustWriteFile(dbFilePath, getterImp)
    }
    getterImp.locker.Unlock()
}

type fileMd5GetterImp struct{
    CacheInfo map[string]*cacheInfoEntry
    locker sync.Mutex
    hasChange bool // 内部的信息是否变化过,以便减少写入成本.
    cacheNow time.Time
    innerBuf []byte
}
type cacheInfoEntry struct{
    MTime time.Time
    Md5 string
    HasCheckInNextSecond bool // 是否在非同一秒,检查过一次md5
}


var fileMd5GetterMap map[string]*fileMd5GetterImp
var fileMd5GetterMapLock sync.Mutex
func (getter *fileMd5GetterImp) getMd5ByFullPath__NOLOCK(path string) string {
    fi,err:=os.Lstat(path)
    if err!=nil{
        return ""
    }
    return getter.getMd5ByStatAndFullPath__NOLOCK(kmgFile.StatAndFullPath{
        Fi: fi,
        FullPath: path,
    })
}
func (getter *fileMd5GetterImp) getMd5ByStatAndFullPath__NOLOCK(statAndFullPath kmgFile.StatAndFullPath) string {
    path:=statAndFullPath.FullPath
    fi:=statAndFullPath.Fi
    var err error
    thisEntry := getter.CacheInfo[path]
    if thisEntry == nil {
        thisEntry = &cacheInfoEntry{}
        thisEntry.MTime = fi.ModTime()
        thisEntry.Md5, err = md5FileWithBuf(path,getter.innerBuf)
        if err != nil {
            return ""
        }
        thisEntry.HasCheckInNextSecond = (getter.cacheNow.Sub(thisEntry.MTime)>time.Second) // 如果mtime已经是很久以前的了,就直接标记已经二次检查了.
        getter.CacheInfo[path] = thisEntry
        getter.hasChange = true
        return thisEntry.Md5
    }
    // 最初版本,用于确保正确性,(后面使用减少syscall的方式来进行优化,会降低可读性.)
    fileMtime:=fi.ModTime()
    if !fileMtime.Equal(thisEntry.MTime){
        // 文件修改时间和储存的文件修改时间 不相同,一定检查md5
        thisEntry.MTime = fileMtime
        thisEntry.Md5, err = md5FileWithBuf(path,getter.innerBuf)
        if err != nil {
            return ""
        }
        thisEntry.HasCheckInNextSecond = (getter.cacheNow.Sub(thisEntry.MTime)>time.Second) // 如果mtime已经是很久以前的了,就直接标记已经二次检查了.
        getter.hasChange = true // 修改时间一定变化过.
        return thisEntry.Md5
    }
    now:=getter.cacheNow
    if now.Sub(thisEntry.MTime)<time.Second{
        // 当前时间和文件修改时间,在同一秒内,(文件修改时间和储存的文件修改时间 相同) 一定检查md5
        md5, err := md5FileWithBuf(path,getter.innerBuf)
        if err != nil {
            return ""
        }
        if md5==thisEntry.Md5 {
            getter.hasChange = true
        }
        thisEntry.Md5 = md5
        thisEntry.HasCheckInNextSecond = false
        return thisEntry.Md5
    }
    if thisEntry.HasCheckInNextSecond==false{
        // 当前是第一次(文件修改时间和储存的文件修改时间 相同,当前时间和文件修改时间,不在同一秒内) 一定检查md5
        thisEntry.MTime = fileMtime
        md5, err := md5FileWithBuf(path,getter.innerBuf)
        if err != nil {
            return ""
        }
        thisEntry.HasCheckInNextSecond = (md5==thisEntry.Md5) // md5 没有变化才设置 当前已经第二次检查过了
        getter.hasChange = true // 要么 thisEntry.HasCheckInNextSecond 变化,要么 md5==thisEntry.Md5 变化.
        thisEntry.Md5 = md5
        return thisEntry.Md5
    }
    // (文件修改时间和储存的文件修改时间 相同,当前时间和文件修改时间,不在同一秒内,当前不是第一次) 直接使用缓存数据就可以了.
    return thisEntry.Md5
}


func getFileMd5GetterByDbFilePath(dbFilePath string) *fileMd5GetterImp {
    fileMd5GetterMapLock.Lock()
    defer fileMd5GetterMapLock.Unlock()
    if fileMd5GetterMap==nil{
        fileMd5GetterMap = map[string]*fileMd5GetterImp{}
    }
    thisGetter:=fileMd5GetterMap[dbFilePath]
    if thisGetter!=nil{
        return thisGetter
    }
    thisGetter = &fileMd5GetterImp{}
    err := kmgGob.ReadFile(dbFilePath, &thisGetter)
    if err != nil {
        //忽略缓存读取的任何错误
        thisGetter = &fileMd5GetterImp{}
    }
    if thisGetter.CacheInfo==nil{
        thisGetter.CacheInfo = map[string]*cacheInfoEntry{}
    }
    if thisGetter.innerBuf == nil{
        thisGetter.innerBuf = make([]byte,32*1024)
    }
    fileMd5GetterMap[dbFilePath] = thisGetter
    return thisGetter
}

// 使用这个方法减少alloc,提高性能约30%.
func md5FileWithBuf(path string,innerBuf []byte) (string,error){
    hash := md5.New()
    f,err:=os.Open(path)
    if err!=nil{
        return "",err
    }
    defer f.Close()
    _,err=io.CopyBuffer(hash,f,innerBuf)
    if err!=nil{
        return "",err
    }
    hashB := hash.Sum(innerBuf[0:0])
    hex.Encode(innerBuf[16:],hashB)
    return string(innerBuf[16:16+32]),nil
}