Repaso general: GoRoutines y apuntadores

4/30
Recursos

Aportes 10

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Codigo acumulado de las clases:

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 8
	y := 7
	fmt.Println(x)
	fmt.Println(y)

	// Capturando valor y error
	myValue, err := strconv.ParseInt("NaN", 0, 64)

	// Validando errores.
	if err != nil {
		fmt.Println("%v\n", err)
	} else {
		fmt.Println(myValue)
	}

	// Mapa clave valor.
	m := make(map[string]int)
	m["key"] = 6
	fmt.Println(m["key"])

	// Slice de enteros.
	s := []int{1, 2, 3}
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}
	s = append(s, 16)
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}

	//c := make(chan int)
	//go doSomething(c)
	//<-c

	g := 25
	fmt.Println(g) // imprime el valor entero 25
	h := &g
	fmt.Println(h) // imprimer la direccion de memoria.
	i := *h
	fmt.Println(i) // Imprime el valor por de g
}

func doSomething(c chan int) {
	time.Sleep(3 * time.Second)
	fmt.Println("done")
	c <- 1
}

https://divan.dev/posts/go_concurrency_visualize/

Un gran articulo para visualizar la concurrencia en Go!!!

Gorutines and chanels

package main

import "time"

func main() {
	c := make(chan int)
	go doSomething(c)
	go doOtherThing()
	go doSomething(c)
	<- c
	print("Lo imprimirá?")

}

func doSomething(c chan int)  {
	time.Sleep(3 * time.Second)
	println("Do something")
	c <- 1
}

func doOtherThing(){
	println("quien se imprimirá primero?")
}

Codigo de esta clase comentado y explicado:

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int) //Creamos un canal para monitorear las Goroutines
	go doSomething(c)   //Llamamos a la función con go para generar un Goroutine
	<-c                 //main esperara a que este canal reciba el mensaje

	g := 25
	fmt.Println(g)
	h := &g         //Apuntador a g
	fmt.Println(h)  //Dirección de memoria donde esta almacenada g
	fmt.Println(*h) //Accedemos al valor de h que a su vez almacena g
}

func doSomething(c chan int) { //Recibimos un canal de tipo int
	time.Sleep(3 * time.Second) //Poner a dormir
	fmt.Println("Done")
	c <- 1 // le envia el valor de 1
}

Aca dejo otro ejemplo simple de lo que es una goroutine Go con ejemplos

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 5
	fmt.Println(x)

	myValue, error := strconv.ParseInt("y", 0, 8)

	if error != nil {
		fmt.Printf("%v\n", error)
	} else {
		fmt.Println(myValue)
	}

	mapa := make(map[string]int)

	mapa["llave"] = 15

	fmt.Println(mapa["llave"])

	mySlice := []int{6, 5, 4}

	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}

	mySlice = append(mySlice, 12)
	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}

	/*miCanal := make(chan int)
	go doSomething(miCanal)
	<-miCanal*/

	g := 25
	fmt.Println(g)

	h := &g
	fmt.Println(h)
	fmt.Println(*h)

}

func doSomething(canal chan int) {
	time.Sleep(3 * time.Second)
	fmt.Println("Listo")
	canal <- 1
}

Que gran repaso

En la parte de Apuntador tambien hay que tener en cuenta que si es cambiado el valor de “g” , la variable “h” tambien tendra el nuevo valor de g

g := 25

fmt.Println(g)

h := &g
fmt.Println(h)
fmt.Println(*h)
g = g + 50
fmt.Println("g:", g, " h: ", *h) \\ g: 75 h: 75
package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	var x int
	x = 8
	y := 7

	fmt.Println(x)
	fmt.Println(y)

	// Handling errors
	myValue, err := strconv.ParseInt("Nan", 0, 64)
	if err != nil {
		fmt.Printf("%v\n", err)
	} else {
		fmt.Printf("%v\n", myValue)
	}

	// Map
	m := make(map[string]int)
	m["Key"] = 6
	fmt.Println(m["Key"])

	// Slice
	s := []int{1, 2, 3, 4, 5}
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Append slice
	s = append(s, 6)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Delete from slice
	s = append(s[:2], s[3:]...)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	// Struct
	type Person struct {
		Name string
		Age  int
	}
	p := Person{"Bob", 20}
	fmt.Println(p.Name)
	fmt.Println(p.Age)

	// Pointer
	var p2 *Person
	p2 = &p
	fmt.Println(p2.Name)
	fmt.Println(p2.Age)

	fmt.Println()

	// Go routines
	c := make(chan int)
	go doSomething(c)

	fmt.Println(<-c)

	fmt.Println()

	// More pointers
	g := 25
	fmt.Println(g)
	h := &g
	fmt.Println(*h)

	*h = 30
	fmt.Println(g)

}

func doSomething(c chan int) {
	fmt.Println("Doing something")
	time.Sleep(1 * time.Second)
	fmt.Println("Done")

	c <- 1
}

Excelente repaso