Pourquoi mon programme Go plante-t-il à cause d'un « trop grand nombre de fichiers ouverts » ?

Go est un langage de programmation très populaire, particulièrement apprécié dans le domaine du développement back-end. Cependant, il y aura parfois un problème de « trop de fichiers ouverts » provoquant le blocage du programme. Cet article vous aidera à répondre à ce problème.

Tout d'abord, comprenons ce qu'est "trop ​​de fichiers ouverts". Dans un programme, le système d'exploitation attribuera un nombre limité de descripteurs de fichiers (fd en abrégé) au programme, qui peuvent être compris comme des identifiants de fichiers ouverts. Lorsqu'un programme ouvre un fichier, il occupe un fd, et lorsque le programme ferme le fichier, le fd est libéré. Ce processus est très courant, par exemple, les descripteurs de fichiers sont utilisés dans des opérations telles que la lecture et l'écriture de fichiers, la création de connexions réseau, etc.

Cependant, le problème est que les descripteurs de fichiers alloués à un programme par le système sont limités. La limite spécifique dépend du système d'exploitation et du matériel. Lorsque le nombre de fichiers ouverts par le programme dépasse la limite donnée par le système, l'erreur « trop de fichiers ouverts » se produit. Cette erreur entraînera le blocage du programme ou entraînera d'autres résultats imprévisibles.

Ensuite, voyons comment éviter ce problème.

La première méthode consiste à utiliser l'instruction with. Cette instruction se retrouve dans de nombreux langages, comme le mot-clé with en Python. Dans Go, nous pouvons utiliser le mot-clé defer pour obtenir des fonctionnalités similaires. L'idée principale de cette méthode est de fermer le fichier immédiatement après que le programme a fini de l'utiliser pour libérer le descripteur de fichier. Voici un exemple :

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    // Do something with the file
}

Dans le code ci-dessus, nous ouvrons un fichier en utilisant la fonction Open du package os et fermons le fichier en utilisant le mot-clé defer à la fin du bloc de code.

La deuxième méthode consiste à ajuster les limites du système. Dans les systèmes Linux, nous pouvons utiliser la commande ulimit pour ajuster le nombre de descripteurs de fichiers alloués à un programme par le système. Nous pouvons entrer la commande suivante dans le terminal pour afficher la limite actuelle :

$ ulimit -n

Si la sortie est 1024, alors la limite actuelle est de 1024 descripteurs de fichiers. Nous pouvons ajuster cette limite à une valeur plus grande à l'aide de la commande suivante :

$ ulimit -n 65535

Cette commande ajuste la limite actuelle à 65535 descripteurs de fichiers. Veuillez noter que cette méthode ne doit être utilisée que dans des circonstances particulières, car elle peut provoquer des pannes du système ou d'autres résultats imprévisibles.

La troisième méthode consiste à utiliser "File Pool". Un pool de fichiers est une structure de données spécialement conçue pour gérer les descripteurs de fichiers, offrant ainsi aux développeurs un meilleur contrôle sur le nombre et l'utilisation des descripteurs de fichiers. Ce qui suit est une implémentation de base d'un pool de fichiers (veuillez noter que cette implémentation est uniquement à titre de démonstration et peut contenir des bugs) :

type filePool struct {
    files   []*os.File
    max     int
    current int
}

func newFilePool(max int) *filePool {
    return &filePool{
        files:   make([]*os.File, max),
        max:     max,
        current: 0,
    }
}

func (fp *filePool) GetFile(filename string) (*os.File, error) {
    var file *os.File
    if fp.current == fp.max {
        return nil, errors.New("filePool full")
    }

    for _, f := range fp.files {
        if f != nil && f.Name() == filename {
            return f, nil
        }
    }

    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }

    fp.files[fp.current] = file
    fp.current++

    return file, nil
}

func (fp *filePool) Close() error {
    for _, f := range fp.files {
        if f != nil {
            f.Close()
        }
    }

    return nil
}

Dans le code ci-dessus, nous définissons une structure filePool, qui comprend un fichier (file descripteur), la liste, le nombre limite maximum et le numéro actuellement utilisé. La méthode GetFile est utilisée pour obtenir des fichiers. Si la limite maximale est dépassée, elle renvoie null et une erreur ; sinon elle vérifie si le fichier est déjà ouvert, elle renvoie le fichier déjà ouvert ; nouveau fichier et l'ajoute à la liste. La méthode Close est utilisée pour fermer tous les fichiers.

Ci-dessus sont trois façons d'éviter les erreurs "trop ​​de fichiers ouverts". L'utilisation de l'instruction with et le regroupement de fichiers sont tous deux des moyens efficaces de gérer le nombre de descripteurs de fichiers, tandis que l'ajustement des limites du système est une option de dernier recours. Dans le développement réel, nous devons utiliser autant que possible les deux premières méthodes et éviter d’utiliser la troisième méthode.

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!