Comment implémenter le verrouillage de fichiers dans Golang

Dans Golang, vous pouvez utiliser l'API du package de synchronisation pour implémenter le verrouillage de fichiers. Un verrou de fichier (flock) est un verrou consultatif pour l'ensemble du fichier ; c'est-à-dire que si un processus place un verrou sur un fichier (inode), les autres processus peuvent le savoir (les verrous consultatifs ne forcent pas le processus à se conformer) ; La syntaxe d'appel est "syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Lorsque nous utilisons le langage Go pour développer certains programmes, il arrive souvent que plusieurs processus exploitent le même fichier en même temps, ce qui peut facilement conduire à une confusion des données du fichier. À l'heure actuelle, nous devons utiliser des moyens pour équilibrer ces conflits, et le verrouillage de fichiers (flock) a vu le jour ci-dessous.

Pour flock, l'exemple le plus courant est Nginx. Une fois le processus exécuté, le PID actuel sera écrit dans ce fichier. Bien sûr, si ce fichier existe déjà, c'est-à-dire que le processus précédent ne s'est pas terminé, alors Nginx ne le fera pas. redémarrer le démarrage, donc flock peut également être utilisé pour détecter si un processus existe.

flock est un verrou consultatif pour l'ensemble du fichier. En d’autres termes, si un processus place un verrou sur un fichier (inode), les autres processus peuvent le savoir (les verrous consultatifs n’obligent pas les processus à s’y conformer). La meilleure partie est que son premier paramètre est un descripteur de fichier, et lorsque ce descripteur de fichier est fermé, le verrou est automatiquement libéré. Une fois le processus terminé, tous les descripteurs de fichiers seront fermés. Bien souvent, il n’est pas nécessaire d’envisager des choses comme le déverrouillage des verrous atomiques.

Avant d'introduire les détails, introduisons d'abord le code

package main
import (
    "fmt"
    "os"
    "sync"
    "syscall"
    "time"
)
//文件锁
type FileLock struct {
    dir string
    f   *os.File
}
func New(dir string) *FileLock {
    return &FileLock{
        dir: dir,
    }
}
//加锁
func (l *FileLock) Lock() error {
    f, err := os.Open(l.dir)
    if err != nil {
        return err
    }
    l.f = f
    err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        return fmt.Errorf("cannot flock directory %s - %s", l.dir, err)
    }
    return nil
}
//释放锁
func (l *FileLock) Unlock() error {
    defer l.f.Close()
    return syscall.Flock(int(l.f.Fd()), syscall.LOCK_UN)
}
func main() {
    test_file_path, _ := os.Getwd()
    locked_file := test_file_path
    wg := sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(num int) {
            flock := New(locked_file)
            err := flock.Lock()
            if err != nil {
                wg.Done()
                fmt.Println(err.Error())
                return
            }
            fmt.Printf("output : %d\n", num)
            wg.Done()
        }(i)
    }
    wg.Wait()
    time.Sleep(2 * time.Second)
}

Lors de l'exécution du code ci-dessus sous le système Windows, l'erreur suivante apparaîtra :

C'est parce que le système Windows ne prend pas en charge le verrouillage pid, nous devons donc exécutez-le sur un système Linux ou Mac Pour exécuter le programme ci-dessus normalement.

Le code ci-dessus montre le démarrage de 10 goroutines en même temps, mais pendant l'exécution du programme, une seule goroutine peut obtenir le verrouillage du fichier (flock). D'autres goroutines lanceront des informations d'exception après avoir échoué à obtenir le troupeau. Cela peut avoir pour effet de permettre à un seul processus d'accéder au même fichier au cours d'une période spécifiée.

L'appel spécifique du verrouillage de fichier dans le code :

syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)

Nous avons utilisé syscall.LOCK_EX, syscall.LOCK_NB.

flock est un cadenas recommandé et n’est pas obligatoire. Un processus utilise flock pour verrouiller le fichier, et l'autre processus peut directement exploiter le fichier verrouillé et modifier les données du fichier. La raison en est que flock n'est utilisé que pour détecter si le fichier est déjà verrouillé. un autre processus Dans le cas de l'écriture de données, le noyau ne bloquera pas l'opération d'écriture de ce processus, qui est la stratégie de traitement du noyau des verrous consultatifs.

flock a trois types d'opérations principaux :

• LOCK_SH : Verrou partagé, plusieurs processus peuvent utiliser le même verrou, souvent utilisé comme verrou partagé en lecture ;

• LOCK_EX : Verrou exclusif, un seul processus est autorisé à utiliser ; en même temps, souvent utilisé comme verrou en écriture

• LOCK_UN : Libérez le verrou.

Lorsqu'un processus utilise flock pour essayer de verrouiller un fichier, si le fichier est déjà verrouillé par un autre processus, le processus sera bloqué jusqu'à ce que le verrou soit libéré, ou que le paramètre LOCK_NB soit utilisé lors de l'appel de flock. Lorsque vous essayez de verrouiller le fichier, il s'avère qu'il a été verrouillé par un autre service et une erreur sera renvoyée avec le code d'erreur EWOULDBLOCK.

La libération du verrouillage du fichier est tout à fait unique. Vous pouvez appeler le paramètre LOCK_UN pour libérer le verrouillage du fichier, ou vous pouvez libérer le verrouillage du fichier en fermant fd (le premier paramètre de flock est fd), ce qui signifie que le flock suivra le processus. est automatiquement libéré une fois fermé.

Pour plus de connaissances sur la programmation, veuillez visiter : Vidéos de programmation ! !

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!