ir lenguaje algunos de los puntos más importantes se resumen (1)

1. Lo primero que hay que decir: cada uno tendrá que aprender sus propias ideas y opiniones, así que mi conclusión sólo puede ser bueno para mí entender, por favor, perdóname.

2. probablemente resumirá el contenido de

• interfaz de lenguaje 1.Go (interfaz)
• 2.goroutine
• 3.channel
  dos siguientes dejará mañana o el día después de escribir un solo día de escritura demasiadas palabras que nadie está dispuesto a ver
• 4. concurrente y cierre de seguridad
• Los dos códigos de entrada web simples (no utilizar marcos)

3. comenzó

interfaz de lenguaje 1.Go

La palabra comenzó a aprender la interfaz de Java han entrado en contacto con, por lo que vamos a hablar de lo que es la interfaz. El funcionario dijo que la interfaz (Interface) es una colección de algunas de las características del método, y en el idioma go es un resumen de interfaces de tipos de datos. Puede ser tan difícil de entender, y luego a escribir con los ejemplos y hablar.

package main

import "fmt"

type dog struct{}

func (d dog) say() {
	fmt.Println("汪汪汪")
}

type cat struct{}

func (c cat) say() {
	fmt.Println("喵喵喵")
}

type person struct {
	name string
}

func (p person) say() {
	fmt.Println("啊啊啊")
}

//接口不注重类型，只注重实现的方法
//只要实现了say()方法的类型就能成为sayer这个接口类型
type sayer interface {
	say()
}

func hit(arg sayer) {
	arg.say()
}

func main() {
	c1 := cat{}
	hit(c1)
	d1 := dog{}
	hit(d1)
	p1 := person{name: "123"}
	hit(p1)
}

Los primeros ejemplos de los que tienen tres estructuras, los perros, los gatos, las personas, y hay maneras de las que llamaban la correspondencia, como un perro ladrar se llama Wang. Esta vez vamos a definir una interfaz de Sayer, siempre y cuando dicen que los instrumentos de tipos de datos () puede convertirse Sayer este tipo de interfaz. Este tiempo para escribir un éxito de función (), el parámetro de entrada es el tipo de interfaz de la variable, de hecho, es el método de todo tipo de implementos dicen (), y luego llama a los parámetros correspondientes método de ejemplo () pasado.

Después de este ejemplo, vamos a ver la interfaz al final lo que es el uso: Si, como de costumbre, hit () parámetros de una función se pasan a una estructura específica, sólo puede lograr un cierto tipo de estructura del método, para los otros dos estructura debe escribir hit2, hit3 para alcanzar, respectivamente. Pero con la interfaz, que todos podemos lograr el mismo tipo de método en una colección, por lo que se puede llamar el mismo método con diferentes tipos de datos en una función.

A continuación, el papel de la interfaz probablemente sabe, vamos a hablar de las interfaces algo para punto de avanzada
aquí destacar dos cosas:
1. un tipo puede implementar múltiples interfaces
2. Diferentes tipos de la misma interfaz también se puede lograr
ejemplo anterior pertenecen a diferentes el mismo tipo de interfaz, de nuevo siguiendo el mismo tipo de un ejemplo diferente de anidado, y la interfaz de

package main

import "fmt"

type mover interface {
	move()
}

type sayer2 interface {
	say()
}

type Person struct {
	name string
	age  int
}

//指针接收者实现接口，赋值的时候只能传入指针！！！而使用值接收者则可以传入值和指针
func (p *Person) move() {
	fmt.Printf("%s在跑\n", p.name)
}

func (p *Person) say() {
	fmt.Printf("%s在叫\n", p.name)
}

//一个类型可以实现多个接口
//不同的类型也可以实现同一个接口
//接口的嵌套
type animal interface {
	mover
	sayer2
}

func main() {
	var m animal
	p1 := &Person{
		name: "hahah",
		age:  18,
	}
	m = p1
	m.move()
	m.say()
	fmt.Println(m)
}

Yo defino la estructura del cuerpo de una persona, los nombres y la edad, sino también para lograr un método dinámico y dos personas llamadas. Además, tengo dos y las interfaces de motor dinámico y sayer2 llamado, esta vez a continuación, utilizar esta interfaz éstos nido dos interfaces animal, que mi pueblo porque este tipo de datos para lograr el movimiento y llamaron también esta interfaz puede ser de tipo animal.

Aquí hay un detalle a la nota, si pongo mi aplicación escrito

func (p Person) move() {
	fmt.Printf("%s在跑\n", p.name)
}

func (p Person) say() {
	fmt.Printf("%s在叫\n", p.name)
}

A continuación, la principal función de instancias o si los valores de punteros entrantes se pueden asignar a esta interfaz animal, pero si, como anteriormente, nuestra interfaz es un puntero a un destinatario que se crea una instancia cuando la asignación P1 persona sólo puede ser un puntero. Ese es el código que la frase cuando una punteros receptores para implementar una asignación de interfaz sólo puede pasar un puntero! ! ! El destinatario puede utilizar el valor de los valores de entrada y punteros
ir en un hecho puntero del lenguaje esto ha sido muy amable, y por lo general se pasa un puntero o valor puede ayudar a que se convierta automáticamente sólo tiene que hacer algo de propia atención especial.

Entonces es aplicaciones afirmación vacíos e interfaces interfaz

//空接口的应用
	//1.可以作为函数的参数，例子：fmt.Println()的参数就是空接口
	//2.作为map的value
	var x = make(map[string]interface{}, 10)
	x["name"] = "xjj"
	x["age"] = 20
	x["hobby"] = []string{"篮球", "唱歌", "敲代码", "玩游戏", "摄影"}
	fmt.Println(x)

	//接口的值由两部分组成：具体的类型+具体类型的值
	//接口的断言
	//开始猜一下接口的类型
	var i interface{}
	i = 123
	ret, ok := i.(string)
	if !ok {
		fmt.Println("不是字符串类型")
	} else {
		fmt.Println("是字符串类型", ret)
	}

	//使用switch进行断言
	switch t := i.(type) {
	case string:
		fmt.Println("是字符串类型", t)
	case bool:
		fmt.Println("是bool类型", t)
	case int:
		fmt.Println("是int类型", t)
	}

interfaz de aire entrante puede ser cualquier tipo de datos, por lo que se utiliza a menudo como el valor del parámetro pasado a la función o en el mapa
resultados anteriores todo el código que se ejecuta

2.goroutine

Hablando goroutine, el primer pensamiento es, sin duda complica por, pero para hablar de concurrencia y era de un gran proceso, hilo, por lo que aquí voy a decir simplemente estos conceptos, después de todo, no se enteraron del sistema operativo cuando no hay graves particularmente claro, ooo, ooo.

Cuando ejecuta una aplicación, y que el sistema operativo se iniciará un proceso para la aplicación. Y cada proceso contiene al menos un hilo, que es el hilo principal, el hilo es para llevar a cabo el espacio, que puede ser utilizado para ejecutar el código que escribimos. Es un lenguaje que ir allí especial nada de ello, el sistema operativo en general son el subproceso de llamada para ejecutarse en el procesador físico, y es para llamar goroutine para salir a correr en procesadores lógicos.

Luego hablar de concurrencia y paralelismo: Use el siguiente ejemplo para entender
la concurrencia y paralelismo
de concurrencia: Al mismo tiempo, también chateo y dos
en paralelo: al mismo tiempo, mi amigo y yo estábamos conversando y profesores
, de hecho, ya que estos desarrolladores van idioma tener un buen paquete, entonces nosotros también necesitamos empezar a no estar tan preocupado por el principio, por lo que en el futuro podría parecer un poco realización avanzada del principio también comprender un poco más conveniente, por lo que primero tome unos ejemplos.

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	runtime.GOMAXPROCS(1)
	var wg sync.WaitGroup
	wg.Add(2)
	fmt.Println("Start Goroutines")

	//声明一个匿名函数创建goroutine
	go func() {
		defer wg.Done()

		//显示小写字母表3次
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
			fmt.Println()
		}
	}()

	//声明一个匿名函数创建goroutine
	go func() {
		defer wg.Done()

		//显示大写字母表3次
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
			fmt.Println()
		}
	}()

	//等待goroutine结束
	fmt.Println("Waiting to finish")
	wg.Wait()
	fmt.Println("Finish!")

}

Este ejemplo se vitrina concurrente alfabeto, de hecho, el programa es concurrente, pero primero goroutine hace demasiado rápido, por lo que cada vez que veo son los primeros en mayúsculas y luego en minúsculas. Este sencillo ejemplo también hay algunos pequeños detalles que requieren atención.
1.runtime.GOMAXPROCS (), el número de procesadores lógicos se designa planificador, una versión anterior por defecto 1,5, después de que el defecto, todos auditoría, si es necesario llamar a esta función se puede configurar.

2.sync Este paquete se utiliza principalmente para goroutine mantenimiento de registros, un semáforo contador es sync.WaitGroup puede grabar ejecución número goroutine, nuestro código Agregar (2) a los dos goroutine que usamos, y requiere el uso de goroutine también es muy sencillo, sólo tiene que ir precedido por la palabra clave. wg.Done () indica que la tarea se ha completado en este momento va a contar el número de WaitGroup anterior -1.

Todas las tareas 3.wg.Wait () va a esperar hasta el final para dejar de esperar, es decir, en términos de cantidad 0
ejemplo anterior o que el código, a fin de lograr lo anterior, dijo, "y al mismo tiempo a dos personas para hablar con el efecto" Designamos procesamiento un aumento en el número, ver el efecto de los concurrentes

cuando ponemos el procesador se pone a 5, se puede ver la situación del caso alternativo, debido a la aleatoriedad intento cuando se puede tratar más de una vez.
También hay un ejemplo simple puede ilustrar este

package main

import (
	"fmt"
	"runtime"
	"sync"
)

//并发和并行
//并发：同一时间段，我同时和两个人聊天
//并行：同一时刻，我和朋友都在和老师聊天

var wg sync.WaitGroup

//goroutine类似于线程（用户态线程）
func hello(i int) {
	fmt.Println("hello goroutine", i)
	wg.Done() //计数器-1
}

func main() {
	runtime.GOMAXPROCS(3) //占用的cpu核数，1.5+默认使用全部核数
	wg.Add(100)           //计数器
	for i := 0; i < 100; i++ {
		go hello(i)
	}
	fmt.Println("hello main")
	//time.Sleep(time.Second)
	wg.Wait() //等待计数器为0才退出
}

3.channel

El principal canal de sincronización del canal, cuando una necesidad de recursos compartidos pueden asegurar la sincronización con el canal para intercambiar datos entre goroutine.
canalizar de dos maneras: canal sin búfer y un canal de memoria intermedia , tendrá que empezar a hablar de la diferencia de su creación.

unbuf:=make(chan int)//无缓冲通道
buf:=make(chan int,10)//有缓冲通道

Tenemos que hacer para crear una función de canal, primero Chan parámetros esenciales, entonces el tipo de datos necesarios para ser aprobada, y, finalmente, la capacidad del canal, no hay un canal de amortiguación.

por cierto, para hacer uso de la función en su lugar principalmente en la marcha:
1.slice crear
2: mapa creado
3: creación de canales

Pero pasó el tiempo que necesitamos para el uso <- operador, cuando el canal es el canal de entrada <-, y se retira del canal es: = <- canal, escribir un ejemplo a la vista.

package main

import "fmt"

//使用并发是为了协同工作，但是交换数据时会发生数据竞态(竞争状态)
//为了保证数据交换，go使用csp并发模型，通过通信共享内存

//channel的操作
//1.发送:<- 2.接收:<- 3.关闭:close()
func main() {
	var ch1 chan int
	//无缓冲区通道：同步通道
	//带缓冲区的通道：异步通道
	ch1 = make(chan int, 1)
	//ch1:=make(chan int,1)
	ch1 <- 10
	x := <-ch1
	fmt.Println(x)
	close(ch1)
}

Este código es muy simple, es para realizar el paso 10 y luego se saca en una impresión

vistazo a la combinación de canal y ejemplos goroutine

package main

import "fmt"

/*
两个goroutine:
1.生成0-100的数字发送到ch1
2.从ch1取出数字并计算平方，把结果发送到ch2
*/

//单向通道:chan<-只能发送，不能取出；<-chan只能取出，不能发送
func f1(ch chan<- int) {
	for i := 0; i < 100; i++ {
		ch <- i
	}
	close(ch)
}

func f2(ch1 <-chan int, ch2 chan<- int) {
	//从通道中循环取值方式1
	for {
		tmp, ok := <-ch1
		if !ok {
			break
		}
		ch2 <- tmp * tmp
	}
	close(ch2)
}

func main() {
	ch1 := make(chan int, 100)
	ch2 := make(chan int, 200)

	go f1(ch1)
	go f2(ch1, ch2)
	//从通道中循环取值方式2
	for ret := range ch2 {
		fmt.Println(ret)
	}
}

Este ejemplo es una goroutine digital generada de 0-100 y transmitida a un canal, un canal de otra goroutine retira antes de calcular el enviado de forma cuadrada para el canal dos. En la presente memoria excepto en combinación que se observó también que un canal de una sola vía.
canal unidireccional: Chan <- única transmisión no se puede quitar; <- Chan solamente puede quitar, no se pueden transmitir
en buen tiempo para el canal unidireccional de definición de función se define, se fija a la dirección del canal. Además canal sin búfer sólo para enviar, recibir y preparar la operación Hou puede lograrse cuando buena, de lo contrario, dará lugar a la ejecución de la operación de bloqueo de espera. El resto vendrá algunos ejemplos para entenderlo.

package main

import (
	"fmt"
	"time"
)

//work pool

func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Printf("worker:%d start job:%d\n", id, job)
		results <- job * 2
		time.Sleep(time.Millisecond * 500)
		fmt.Printf("worker:%d stop job:%d\n", id, job)
	}
}

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

	//开启三个goroutine
	for j := 0; j < 3; j++ {
		go worker(j, jobs, results)
	}
	//发送五个任务
	for i := 0; i < 5; i++ {
		jobs <- i
	}
	close(jobs)
	for i := 0; i < 5; i++ {
		ret := <-results
		fmt.Println(ret)
	}
}

package main

import "fmt"

//select多路复用
/*
select的使用类似于switch,满足多个条件时会随机取一个任务
*/

func main() {
	ch := make(chan int, 1)
	for i := 0; i < 10; i++ {
		select {
		case x := <-ch:
			fmt.Println(x)
		case ch <- i:
		default:
			fmt.Println("什么都不干")
		}
	}
}

El último ejemplo es el canal multiplexado, la pluralidad de condiciones se satisfacen cuando se utiliza seleccionar aleatoriamente seleccionar una tarea, ya que la capacidad del canal es superior a 1, se puede almacenar uno debe retirarse, sólo se puede obtener un número par.

resumen:

Hoy por ejemplo es el lenguaje ir y varios otros idiomas, y es el lugar más atractivo, todavía tenemos una buena digestión. Mañana va a terminar las dos partes restantes, y luego ir después del contenido idioma de escritura va a escribir algunas palabras sobre la parte web o rastreadores.

Por último sentimiento sobre, agotador casa de vacaciones de invierno que en la escuela (principalmente cansado corazón), al menos, las escuelas son gratuitas, algunas personas en el país, más se quieren verlo aún más para unirse a su cara, muy enfermo de la misma .