Système de fichiers, multi-threading, traitement du signal en langage Go

Avec l'avancement et le développement continus de la technologie informatique, de plus en plus de langages de programmation ont émergé, parmi eux, le langage Go a attiré l'attention de plus en plus de développeurs et d'entreprises en raison de ses puissantes capacités de concurrence, de son mécanisme de récupération de place et autres. caractéristiques et largement utilisé. Parmi eux, le système de fichiers, le multithreading et le traitement du signal sont quelques-unes des fonctionnalités les plus importantes du langage Go. Cet article détaillera les principes et applications de ces fonctionnalités.

1. Système de fichiers

Le langage Go fournit des interfaces liées aux opérations sur les fichiers via le package os. Par exemple, le package os fournit la structure File pour représenter les fichiers et fournit des méthodes telles que Open et Create pour ouvrir et créer des fichiers. Il fournit également des méthodes telles que Close, Stat, Read et Write pour gérer les fichiers. Le code est le suivant :

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    file.Write([]byte("hello world
"))
    file.Sync()

    file, err = os.Open("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    data := make([]byte, 100)
    count, err := file.Read(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("read %d bytes from file: %s", count, data)
}

Dans le code ci-dessus, nous avons créé et ouvert un fichier nommé test.txt via le package os, y avons écrit une ligne de chaîne "hello world", puis avons synchronisé les données du cache dans le fichier. Ensuite, nous rouvrons le fichier, lisons son contenu et l'imprimons. Il convient de noter que nous utilisons l'instruction defer pour garantir que le fichier est fermé à la fin de la fonction afin d'éviter les fuites de ressources.

De plus, le langage Go fournit également le package path et le package filepath pour gérer les problèmes liés au chemin des fichiers. Par exemple, le package path fournit des méthodes telles que Join, Dir et Base pour gérer les chaînes de chemin, tandis que le package filepath fournit des méthodes telles que Clean, Join et Split pour gérer des problèmes tels que les séparateurs de chemin sous différents systèmes d'exploitation.

2. Multi-threading

Le langage Go offre de puissantes capacités de programmation simultanée sous la forme de goroutines et de canaux. Les coroutines sont des threads légers qui peuvent être facilement créés et détruits, et leur coût de changement de contexte est très faible, prenant ainsi en charge la création et l'exécution d'un grand nombre de coroutines. Les canaux constituent le mécanisme de base de la communication entre les coroutines, leur permettant de transférer et de partager des données sans verrous. Le code est le suivant :

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d started job %d
", id, j)
        time.Sleep(time.Second)
        fmt.Printf("worker %d finished job %d
", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}

Dans le code ci-dessus, nous définissons un travailleur de coroutine de travail, qui lit les tâches du canal des tâches, exécute les tâches, puis écrit les résultats dans le canal des résultats. Nous avons créé trois coroutines de travail via des boucles et transmis les tâches et les canaux de résultats en tant que paramètres. Ensuite, nous plaçons 9 tâches dans le canal des tâches et lisons les résultats lorsque les tâches sont terminées. Il convient de noter que nous utilisons l'instruction close pour fermer le canal jobs afin d'indiquer à la coroutine de travail qu'il n'y a plus de tâches à exécuter.

De plus, le langage Go fournit également des mécanismes tels que des verrous mutex et des verrous en lecture-écriture dans le package de synchronisation pour garantir la sécurité d'accès aux ressources partagées. Par exemple, lors de la lecture et de l'écriture de variables partagées, nous pouvons utiliser un verrou mutex pour garantir qu'une seule goroutine puisse accéder à la variable en même temps.

3. Traitement du signal

Le langage Go fournit le package OS pour traiter les signaux (signal). Les signaux sont une méthode de communication inter-processus dans les systèmes UNIX/Linux. Ils sont utilisés pour informer les processus de l'apparition d'un certain événement, tel qu'une interruption, une terminaison, etc.

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    fmt.Println("awaiting signal")
    <-sigs
    fmt.Println("exiting")
}

Dans le code ci-dessus, nous avons capturé les signaux SIGINT et SIGTERM via le package de signaux et les avons liés au canal sigs via la fonction Notify. Ensuite, nous attendons que le signal arrive en lisant le signal du canal sigs. Il convient de noter que nous utilisons des constantes définies dans le package syscall pour représenter le type de signal. Par exemple, SIGINT représente un signal d'interruption et SIGTERM représente un signal de terminaison.

De plus, nous pouvons également personnaliser les types de signaux et utiliser le package os/signal pour les traiter dans le programme. Par exemple, nous pouvons implémenter des mécanismes simples de synchronisation d'état partagé tels que des verrous distribués via des signaux personnalisés dans le programme.

En résumé, le système de fichiers, le multi-threading et le traitement du signal sont quelques-unes des fonctionnalités les plus importantes du langage Go. Leur utilisation combinée nous permet d'écrire des programmes efficaces et robustes. Dans le même temps, en raison de la syntaxe simple et de la bonne conception simultanée du langage Go, il convient à une utilisation dans le cloud computing, la conteneurisation et d'autres domaines, et constitue un langage de programmation qui constitue une tendance future.

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!