Qu'est-ce que l'instruction d'exécution différée en langage Go

En langage Go, l'instruction d'exécution retardée est l'instruction defer, et la syntaxe est "différer toute instruction". L'instruction defer retardera le traitement des instructions qui la suivent. Lorsque la fonction à laquelle appartient l'option defer est sur le point de revenir, les instructions différées seront exécutées dans l'ordre inverse de defer ; exécuté en dernier, et l'instruction différée en dernier sera exécutée en premier.

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

Instruction d'exécution différée (instruction defer) en langage Go

Il existe une instruction d'exécution différée en langage Go, qui est identifiée par le mot-clé defer.

Le mot-clé defer retardera le traitement des instructions qui le suivent. Lorsque la fonction à laquelle appartient defer est sur le point de revenir, les instructions retardées seront exécutées dans l'ordre inverse de defer. first sera exécuté en dernier. L'instruction différée en dernier est exécutée en premier.

Le format est le suivant :

defer 任意语句

Les instructions après defer ne seront pas exécutées immédiatement lorsque la fonction à laquelle defer appartient est sur le point de revenir, toutes les instructions defer dans le corps de la fonction seront exécutées dans l'ordre inverse de. apparence, c'est-à-dire la dernière instruction du corps de la fonction. Une instruction defer est exécutée en premier.

package main

import "fmt"

func main(){
	fmt.Println("start now")
	defer fmt.Println("这是第一句defer语句")
	defer fmt.Println("这是第二句defer语句")
	defer fmt.Println("这是第三句defer语句")
	fmt.Println("end")
}

Le résultat de l'exécution est le suivant :

start now
end
这是第三句defer语句
这是第二句defer语句
这是第一句defer语句

Étant donné que l'instruction defer est appelée lorsque la fonction actuelle est sur le point de revenir, defer est souvent utilisé pour libérer des ressources.

L'ordre de traitement de plusieurs instructions d'exécution retardée

Lorsque plusieurs comportements de report sont enregistrés, ils seront exécutés dans l'ordre inverse (semblable à une pile, c'est-à-dire dernier entré, premier sorti). d'instructions numériques Retarder le traitement dans l'ordre suivant :

package main
import (
    "fmt"
)
func main() {
    fmt.Println("defer begin")
    // 将defer放入延迟调用栈
    defer fmt.Println(1)
    defer fmt.Println(2)
    // 最后一个放入, 位于栈顶, 最先调用
    defer fmt.Println(3)
    fmt.Println("defer end")
}

La sortie du code est la suivante :

defer begin
defer end
3
2
1

L'analyse des résultats est la suivante :

• L'ordre de retard du code est inversé par rapport à l'ordre d'exécution final.

• L'appel différé est effectué lorsque la fonction où se trouve le defer se termine. La fin de la fonction peut être lorsqu'elle revient normalement ou lorsqu'un temps d'arrêt se produit.

Utilisez des instructions d'exécution différée pour libérer des ressources lorsque la fonction se termine

Le traitement d'opérations couplées impliquées dans le business ou la logique est une tâche relativement lourde, comme l'ouverture et la fermeture de fichiers, la réception et la réponse aux demandes, ainsi que le verrouillage et le déverrouillage. etc. Parmi ces opérations, la plus facilement négligée est la libération et la fermeture correctes des ressources à chaque sortie de fonction.

L'instruction defer est exactement l'instruction qui est exécutée lorsque la fonction se termine, donc l'utilisation de defer peut gérer très facilement les problèmes de libération de ressources.

1) Utiliser le déverrouillage simultané retardé

Dans l'exemple suivant, la carte sera utilisée simultanément dans la fonction. Pour éviter les conditions de concurrence, sync.Mutex est utilisé pour le verrouillage. Voir le code ci-dessous :

var (
    // 一个演示用的映射
    valueByKey      = make(map[string]int)
    // 保证使用映射时的并发安全的互斥锁
    valueByKeyGuard sync.Mutex
)
// 根据键读取值
func readValue(key string) int {
    // 对共享资源加锁
    valueByKeyGuard.Lock()
    // 取值
    v := valueByKey[key]
    // 对共享资源解锁
    valueByKeyGuard.Unlock()
    // 返回值
    return v
}

La description du code est la suivante. suit :

• Ligne 3, instanciez une carte, la clé est de type chaîne et la valeur est int.

• Ligne 5, la carte n'est pas sécurisée par défaut en matière de concurrence, préparez un mutex sync.Mutex pour protéger l'accès à la carte.

• Ligne 9, la fonction readValue() donne une clé et renvoie la valeur après avoir obtenu la valeur de la carte. Cette fonction sera utilisée dans un environnement concurrent et doit garantir la sécurité de la concurrence.

• Ligne 11, utilisez mutex pour verrouiller.

• Ligne 13, obtenez la valeur de la carte.

• Ligne 15, déverrouillez en utilisant mutex.

• Ligne 17, renvoie la valeur cartographique obtenue.

Utilisez l'instruction defer pour simplifier l'instruction ci-dessus, reportez-vous au code ci-dessous.

func readValue(key string) int {
    valueByKeyGuard.Lock()
   
    // defer后面的语句不会马上调用, 而是延迟到函数结束时调用
    defer valueByKeyGuard.Unlock()
    return valueByKey[key]
}

Les lignes 6 à 8 du code ci-dessus sont des modifications et des ajouts au code précédent. La description du code est la suivante :

• La ligne 6 utilise l'instruction defer pour ajouter le déverrouillage une fois le mutex verrouillé. ne sera pas exécuté immédiatement, mais sera exécuté au retour de la fonction readValue().

• Ligne 8, le processus d'interrogation de la valeur de la carte et de son retour est le même que la manière d'écrire sans utiliser de mutex. Par rapport au code ci-dessus, cette façon d'écrire est plus simple.

2) Utilisation du gestionnaire de fichier à libération retardée

Les opérations sur les fichiers nécessitent plusieurs processus : l'ouverture du fichier, l'obtention et l'exploitation des ressources du fichier, et la fermeture des ressources. Si les ressources du fichier ne sont pas fermées une fois l'opération terminée, le processus le fera. ne pourra jamais libérer les ressources du fichier, dans l'exemple suivant, une fonction permettant d'obtenir la taille du fichier en fonction du nom du fichier sera implémentée. La fonction nécessite des opérations telles que l'ouverture du fichier, l'obtention de la taille du fichier et la fermeture du fichier. . Étant donné que chaque opération du système nécessite une gestion des erreurs, chaque étape du traitement provoquera une erreur de sortie possible, les ressources doivent donc être libérées lors de la sortie, et nous devons prêter une attention particulière à la libération correcte des ressources du fichier à la sortie de la fonction. code suivant :

// 根据文件名查询其大小
func fileSize(filename string) int64 {
    // 根据文件名打开文件, 返回文件句柄和错误
    f, err := os.Open(filename)
    // 如果打开时发生错误, 返回文件大小为0
    if err != nil {
        return 0
    }
    // 取文件状态信息
    info, err := f.Stat()
   
    // 如果获取信息时发生错误, 关闭文件并返回文件大小为0
    if err != nil {
        f.Close()
        return 0
    }
    // 取文件大小
    size := info.Size()
    // 关闭文件
    f.Close()
   
    // 返回文件大小
    return size
}

La description du code est la suivante :

• Ligne 2, définissez la fonction d'acquisition de taille de fichier, la valeur de retour est la valeur de taille de fichier de 64 bits.

• Ligne 5, utilisez la fonction Open() fournie par le package os pour ouvrir un fichier en fonction du nom de fichier donné, et renvoyez le handle utilisé pour faire fonctionner le fichier et l'erreur d'opération.

• Ligne 8, si une erreur se produit lors du processus d'ouverture, telle que le fichier n'est pas trouvé, le fichier est occupé, etc., la taille du fichier sera renvoyée à 0.

• 第 13 行，此时文件句柄 f 可以正常使用，使用 f 的方法 Stat() 来获取文件的信息，获取信息时，可能也会发生错误。

• 第 16～19 行对错误进行处理，此时文件是正常打开的，为了释放资源，必须要调用 f 的 Close() 方法来关闭文件，否则会发生资源泄露。

• 第 22 行，获取文件大小。

• 第 25 行，关闭文件、释放资源。

• 第 28 行，返回获取到的文件大小。

在上面的例子中，第 25 行是对文件的关闭操作，下面使用 defer 对代码进行简化，代码如下：

func fileSize(filename string) int64 {
    f, err := os.Open(filename)
    if err != nil {
        return 0
    }
    // 延迟调用Close, 此时Close不会被调用
    defer f.Close()
    info, err := f.Stat()
    if err != nil {
        // defer机制触发, 调用Close关闭文件
        return 0
    }
    size := info.Size()
    // defer机制触发, 调用Close关闭文件
    return size
}

代码中加粗部分为对比前面代码而修改的部分，代码说明如下：

• 第 10 行，在文件正常打开后，使用 defer，将 f.Close() 延迟调用，注意，不能将这一句代码放在第 4 行空行处，一旦文件打开错误，f 将为空，在延迟语句触发时，将触发宕机错误。

• 第 16 行和第 22 行，defer 后的语句（f.Close()）将会在函数返回前被调用，自动释放资源。

【相关推荐：Go视频教程、编程教学】

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!