Auteur | Ma Chao

Zebian | yugao

Photo de couverture | RPSC téléchargé à partir de la Chine Vision

Produit | RPSC (ID: CSDNnews)

Au début de Mars de cette année, Tencent a publié « Tencent R & D Big Data Report », l'auteur a constaté que l'utilisation de la langue dans l'usine de GO a augmenté à la position du TOP5.

Nous savons que Tencent en particulier récipient Docker de celui-ci, est à l'avant-garde de la grande usine, en particulier les GO en fonction de leur développement linguistique Devops plate-forme de baleines bleues, très haut niveau.

Par l'auteur de l'expérience sur le terrain pour commencer, la langue GO en termes de concurrence est encore assez bon, après l'auteur de faire rapport sur les derniers résultats.

A propos de GO langue tranche

Tranche (slice) est une référence à un tableau de segments consécutifs, de sorte que la même tranche est un type de référence, le type de liste Python est relativement similaire, les fragments peuvent être ensemble du réseau peut également être une identification de début et de fin de l'indice sous-ensemble d'éléments. Go langues contiennent une configuration interne de la tranche d'adresse, les caractéristiques de tranche par rapport à la taille maximale (x) et une capacité (CAP) et la capacité de réseau est variable.

Interprétation des codes de langue GO

1. append élément additif fonctionnel

Fonctions intégrées append éléments de langage Go peuvent être dynamiquement ajoutés à la tranche, mais il faut noter que, en raison de la tranche elle-même longueur variable, donc, utilisez la fonction append pour ajouter des éléments dynamiques tranche, tranche sera automatiquement « expansion », tandis que longueur des nouvelles puces augmentera aussi, mais une chose à noter, append retourne un nouvel objet tranche, plutôt que l'opération de découpage d'origine. Dans le code suivant, nous définissons d'abord une tranche, et de manière append en augmentant continuellement ses éléments, et observé les variations de longueur et de volume d'une tranche.

principale du paquet importation ( "fmt") func principale { var un entier // définir un fmt.Printf de tranche ( "len:% capuchon de d:% pointeur de d:% p \ n", len (a), le bouchon (a), a) // A cette longueur de découpage de temps et la taille est égal à 0, le résultat est exécuté len: 0 cap: 0 pointeur: 0x0a = append (a, 1) // ajout d'un fmt.Printf d'élément ( "len:% capuchon de d:% pointeur de d:% p \ n", len (a), bouchon (a), a) // Notez que le moment d'un changement d'adresse pour la nouvelle tranche a eu lieu, de nouvelles tuiles courir la longueur et la taille du résultat est 1: len: 1 bouchon: 1 pointeur: 0xc000072098a = append (a, 2, 3, 4) // ajout d'une pluralité d'éléments fmt.Printf ( "len:% capuchon de d:% pointeur de d:% p \ n", len (a), le capuchon (a), a) / / note à ce moment un changement d'adresse se produit à nouveau et effectivement généré une nouvelle tranche, la nouvelle tranche de la longueur et la taille de 4 résultats run: len: 4 cap: 4 pointeur: 0xc000070160a = append (a, 5) // l'ajout d'un fmt.Printf élément supplémentaire ( "len:% capuchon de d:% pointeur de d:% p \ n", len (a), le bouchon (a), a) // stratégie d'expansion de la capacité de la tranche de la note est modifiée à partir de 4 Mode multiplication à 8, et la longueur est de 5 résultats d'exécution: len: 4: 4 bouchon pointeur: 0xc000070160 }

Tranche peut être observée lors de l'expansion, sa vitesse capacité (CAP) droit est effectuée par multiples de deux.

2. Supprimez la tranche d'éléments

A partir des sections antérieures de N éléments

Utilisation réalisation x = x N éléments à supprimer à partir du i-ième élément dans la tranche

Code spécifique, comme suit:

principale du paquet importation ( "fmt") func principale {var a = int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // méthode de déclarer que défini dans l'original et initialiser une tranche fmt.Println (a) // Résultats Run après suppression de a = a // // supprimer le premier élément d'un premier élément 1 fmt.Println (a), avant que le résultat de l'action est a = 2 a @ suppression d'éléments fmt.Println (a) // tête d'effacement après les deux premiers éléments, les résultats pour le }

3, la compréhension en profondeur des sections linguistiques GO

L'emplacement des sections de code dans GOPATH \ src \ Runtime \ slice.go, qui, pour l'interprétation de plusieurs fonctions clés comme suit:

Définition de la structure de 1.slice

Tout d'abord, une structure de tranche est telle qu'il a une matrice de données stockée, et une longueur len configuration de capuchon et de la capacité

struct type de tranche { tableau unsafe.Pointer int len} int cap

2. Créez une tranche de la fonction makeslice

La fonction de création en tranches makeslice ci-dessous, vous pouvez voir la fonction sera pré-allouée à la mémoire, en cas de succès puis allouer officiellement la mémoire, il a construit une tranche de code source de la fonction makeslice et commentaires comme suit:

func makeslice (et * _type, len, cap int) tranche { mem, overflow: = math.MulUintptr (et.size, UIntPtr (cap)) // Cette fonction calcule la taille de chaque élément est et.size espace occupé, et multiplié par la capacité CAP, qui est nécessaire à la fois mem si la mémoire maximale, représentant de débordement provoque le débordement si débordement || mem >  maxalloc || len <  0 || len >  capuchon {// détermine si un dépassement de capacité, négatif ou longueur longitudinale plus grande que la capacité de l'espèce, car il y a une panique directe // NOTE: produire un « len hors de portée » erreur au lieu d'une // « bouchon hors de portée » erreur lorsque quelqu'un ne fait (T, bignumber) .// « bouchon hors de portée » est vrai aussi, mais étant donné que le bouchon est uniquement // fourni implicitement, en disant len est clearer.// Voir golang.org/issue/4085.mem , overflow: = math.MulUintptr (et.size, UIntPtr (LEN)) si débordement || mem >  maxalloc || len <  0 {} panicmakeslicelen panicmakeslicecap} mallocgc de retour (mem, et, true) // Si le contrôle d'erreur est réussie, l'allocation de la mémoire, des objets de tranche d'attention sera effacée automatiquement GC. }

3. Fonction Expansion growslice

Growslice en lisant la source peut le voir sur cette fonction parmi la règle d'extension est plus court que le temps pour l'expansion 1024 est doublée en conformité avec le mode de réalisation a été utilisée, elle est supérieure à 1024, chaque étendue à 1,25 fois le volume initial, la capacité de la nouvelle après l'achèvement du calcul effectué pour la pré-allocation de la mémoire, ceci est aussi compatible avec la makeslice idée, puis reprendre les anciennes données sont copiées sur une nouvelle tranche de la tranche de manière memmove (p, old.array, lenmem). fonction growlice code source et les commentaires sont les suivants:

func growslice (et * _type, ancienne tranche, cap int) tranche { // simplement l'expansion, les données ne pas écrire si et.size == 0 {if cap <  old.cap {panique (errorString ( « growslice: cap hors de portée »))}. // append ne devrait pas créer une tranche avec pointeur nul mais non nul len // On suppose que append n'a pas besoin de préserver les anciens. tableau dans ce cas. retour tranche {unsafe.Pointer (& zerobase), old.len, cap}} // nouvelle règle d'expansion 1. 2 fois plus grand que l'ancien, directement à l'expansion de la nouvelle capacité // 2. nouvelles capacités pas plus de deux fois le vieux, quand une longueur inférieure à 1024, l'ancienne extension à 2 fois ou 1,25 fois l'ancienne extension à Newcap: = old.cap doublecap: = + Newcap Newcap si capuchon >  doublecap {Newcap = cap} else {if old.len <  1024 {Newcap = doublecap} else {Newcap <  {cap Newcap + = Newcap / 4}}} // Selon tranche avec le type et la capacité de calcul de la taille de la mémoire à allouer overflow var Boolvar lenmem, newlenmem, commutateur de capmem UIntPtr {case et.size == 1: lenmem = UIntPtr (old.len) newlenmem = UIntPtr (cap) capmem = roundupsize (UIntPtr (Newcap)) = débordement UIntPtr (Newcap) >  maxAllocnewcap = int (capmem) et.size cas == sys.PtrSize: lenmem = UIntPtr (old.len) * sys.PtrSizenewlenmem = UIntPtr (cap) * = sys.PtrSizecapmem roundupsize (UIntPtr (Newcap) * sys.PtrSize) trop-plein = UIntPtr (Newcap) >  maxalloc / sys.PtrSizenewcap = int (capmem / sys.PtrSize) isPowerOfTwo cas (et.size): déplacement var uintptrif sys.PtrSize == 8 {// Masque décalage pour un meilleur code generation.shift = UIntPtr (sys.Ctz64 (uint64 (et.size))) & 63} else {shift = UIntPtr (sys.Ctz32 (uint32 (et.size))) et 31} lenmem = UIntPtr (old.len) < <  shiftnewlenmem = UIntPtr (cap) < <  shiftcapmem = roundupsize (UIntPtr (Newcap) < <  shift) = débordement UIntPtr (Newcap) >  (maxalloc > >  shift) Newcap = int (capmem > >  shift) par défaut: lenmem = UIntPtr (old.len) * et.sizenewlenmem = UIntPtr (cap) * et.sizecapmem, débordement = math.MulUintptr (et.size, UIntPtr (Newcap)) capmem = roundupsize (capmem) Newcap = int (capmem / et.size)} // anomalie, l'ancienne capacité supérieure à la capacité d'un nouveau ou une nouvelle limite de capacité a été dépassée si le bouchon <  old.cap || UIntPtr (Newcap) >  maxSliceCap (et.size) {panique (errorString ( "growslice: cap hors de portée"))} var p unsafe.Pointer si et.kind & kindNoPointers! = 0 { // débités en morceaux d'ouvrir un nouvel espace d'adressage capmem de capacité p = mallocgc (capmem, nul, false) // tranche des anciennes données déplacés vers une nouvelle adresse tranchée ouverte dans memmove (p, old.array, lenmem) // l'append que les appels growslice va écraser de old.len à capuchon (qui sera la nouvelle longueur). // seulement effacer la partie que la nouvelle tranche d'adresses restantes ne seront pas overwritten.// en nettoyage, le pointeur de la pile ne peut pas être stocké // memclrNoHeapPointers n octets Clairs à partir de ptr.//// Habituellement, vous devez utiliser typedmemclr memclrNoHeapPointers devrait être utilisé que // lorsque l'appelant sait que * ptr ne contient pas de pointeurs tas // car soit :. //// 1. * PTR est la mémoire initialisées et son type est pointer-free.//// 2. * ptr est une mémoire non initialisée (par exemple, la mémoire qui est réutilisée // pour une nouvelle allocation) et ne contient donc que « junk ». memclrNoHeapPointers (add (p , newlenmem), capmem-newlenmem)} else {// note: ne peut pas utiliser rawmem (ce qui évite la mise à zéro de la mémoire), car alors GC peut analyser la mémoire non initialisée p = mallocgc (capmem, et, true) si writeBarrier.!. {permis memmove (p, old.array, lenmem)} else {pour i: = UIntPtr (0); i <  lenmem; i + = {et.size typedmemmove (et, add (p, i), ajouter (old.array, i))}}} tranche de retour {p, old.len, Newcap}}

GO sections linguistiques des conclusions pertinentes

Donc, en lisant le code source ci-dessus, nous pouvons également savoir qu'il ya les deux conclusions suivantes:

Lorsque le mode append pour augmenter les éléments de données, si l'expansion de la tranche de déclenchement, il est devenu sans aucun doute un objet de tranche de première année et impliquent des opérations de mémoire, de sorte que l'opération append doit être prudent.

Nous avons recommandé de déclarer une tranche par la fonction de marque, et autant que possible lors de la configuration initiale une valeur de capacité raisonnable, éviter une expansion fréquente en tranches apportent une surcharge inutile.

Lien original:

https://blog.csdn.net/BEYONDMA/article/details/104799500

avantages Aujourd'hui

Lu Qi a rencontré

Par ailleurs, une part importante de « millions de gens apprennent AI » est, 2020 AIProCon Developers Conference les gens vont vivre à travers des formulaires en ligne, ce qui permet aux développeurs à 3 Juillet à 4-stop pour en savoir plus sur l'IA actuel de la technologie de pointe la recherche, la technologie de base et des applications ainsi que l'expérience pratique dans le cas d'une entreprise, mais peuvent également participer à une variété de développeur en ligne passionnant Sharon et les projets de programmation. Potentiels comportait une série d'activités, l'interaction en direct, non seulement peuvent communiquer avec des dizaines de milliers de développeurs, ainsi que la chance de gagner des cadeaux exclusifs en direct, du café et même grand blé technologie.