Golang如何保证不重复执行同一个进程

第一版：

我们用一个文件的存在与否标识进程是否正在执行（很明显每个进程对应一个文件 - PID文件）

package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    // 1 定义当前进程PID文件
    sigfile := "./cli_syncStaffs.pid"

    _, err := os.Stat(sigfile)
    if err == nil {
        //pid文件存在-进程已经存在
        fmt.Println("PID file exist.running...")
        os.Exit(0)
    }

    // 2 创建当前进程的pid文件
    pidFileHandle, err := os.OpenFile(sigfile, os.O_RDONLY|os.O_CREATE, os.ModePerm)
    if err != nil {
        panic(err)
    }

    // 执行业务逻辑
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    time.Sleep(25*time.Second)
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
        
    // 执行完毕
    err= pidFileHandle.Close()
    if err!=nil {
        fmt.Println(err)
    }
    // 删除该文件
    err = os.Remove(sigfile)
    if err!=nil {
        fmt.Println(err)
    }
}

于是，如果一个进程正在执行的时候，另一个进程执行的话会抛出：

但是，当并发量大的时候 ( 下面我们模拟10个并发 )

package main

import (
    "fmt"
    "os"
    "sync"
    "time"
)

var wg sync.WaitGroup

func main() {
    for i :=0 ; i<10 ;i++{
        fmt.Println("start ",i)
        wg.Add(1)
        go test()  //启动10个goroutine 来计算
    }
    // 阻塞-保证子协程跑完
    wg.Wait()
}

func test(){
    defer wg.Done()
    // 1 定义当前进程PID文件
    sigfile := "./cli_syncStaffs.pid"
    _, err := os.Stat(sigfile)
    if err == nil {
        //pid文件存在-进程已经存在
        fmt.Println("PID file exist.running...")
        return
    }
    // 2 创建当前进程的pid文件
    pidFileHandle, err := os.OpenFile(sigfile, os.O_RDONLY|os.O_CREATE, os.ModePerm)
    if err != nil {
        fmt.Println(err)
        return
    }
    // 执行业务逻辑
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    time.Sleep(5*time.Second)
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    // 执行完毕
    err= pidFileHandle.Close()
    if err!=nil {
        fmt.Println(err)
        return
    }
    // 删除该文件
    err = os.Remove(sigfile)
    if err!=nil {
        fmt.Println(err)
        return
    }
}

很明显正常来说，即使再快，也是有次序的，也就是说，这10个协程之中，只有一个会输出时间戳（其他都会告知，pid file exist，running...）

但是输出却是这样的

 很明显，

单纯依靠文件是否存在并不能保证进程执行的时候其他进程一定无法执行

我们应该给文件上锁（并发安全），

当文件无法加锁的时候，就是有进程正在跑

于是改一下程序：

package main

import (
    "fmt"
    "os"
    "sync"
    "syscall"
    "time"
)

var wg sync.WaitGroup

func main() {
    for i :=0 ; i<10 ;i++{
        fmt.Println("start ",i)
        wg.Add(1)
        go test()  //启动10个goroutine 来计算
    }
    // 阻塞-保证子协程跑完
    wg.Wait()
}

func test(){
    defer wg.Done()
    // 1 定义当前进程PID文件
    sigfile := "./cli_syncStaffs.pid"
    // 1 获取当前的pid文件(没有就自动创建)
    pidFileHandle, err := os.OpenFile(sigfile, os.O_RDONLY|os.O_CREATE, os.ModePerm)
    if err != nil {
        fmt.Println("open fail.")
        fmt.Println(err)
        return
    }
    defer pidFileHandle.Close()

    // 2 文件加锁
    err = syscall.Flock(int(pidFileHandle.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        fmt.Println(err)
        fmt.Println("running...")
        return
    }
    defer syscall.Flock(int(pidFileHandle.Fd()), syscall.LOCK_UN)
    // 执行业务逻辑
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    time.Sleep(5*time.Second)
    fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
    return
}

注意：文件加锁不支持Windows上运行

以上正确输出：

start  0
start  1
start  2
start  3
start  4
start  5
start  6
start  7
start  8
start  9
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
resource temporarily unavailable
running...
2020-11-20 01:42:05
2020-11-20 01:42:10

参考博客

https://www.cnblogs.com/pingyeaa/p/11418527.html