Comment garantir qu'une seule instance d'un exécutable Golang s'exécute sous Windows ?

Assurer l'exécution d'une seule instance d'un exécutable Golang sous Windows

Pour empêcher plusieurs instances d'un exécutable de s'exécuter simultanément, implémenter un mécanisme Global Mutex est essentiel. Voici une solution pour y parvenir dans Golang sur une machine Windows :

Utilisation d'un mutex global :

La solution consiste à créer un mutex global à l'aide de la fonction CreateMutex de Windows noyau. Un mutex global est accessible sur différentes sessions utilisateur, garantissant qu'une seule instance de l'exécutable peut s'exécuter à la fois.

Exemple de code :

Le code Go suivant montre comment créer un global mutex :

import (
    "syscall"
    "unsafe"
)

// CreateMutex creates a global mutex.
func CreateMutex(name string) (uintptr, error) {
    kernel32 := syscall.NewLazyDLL("kernel32.dll")
    procCreateMutex := kernel32.NewProc("CreateMutexW")

    ret, _, err := procCreateMutex.Call(
        0,
        0,
        uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(name))),
    )
    if int(err.(syscall.Errno)) == 0 {
        return ret, nil
    }

    return ret, err
}

// SampleMutexName provides an example of creating a global mutex.
func SampleMutexName() {
    _, err := CreateMutex("Global\MyMutexName")
    if err != nil {
        // Handle error
    }
}

Conclusion :

En créant un mutex global, vous pouvez vous assurer qu'une seule instance de votre exécutable Golang est en cours d'exécution à un moment donné. Cette solution empêche efficacement plusieurs instances de consommer inutilement des ressources système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!