En el lenguaje Gox, básicamente hereda el mecanismo de concurrencia del lenguaje Go y el tipo de canal chan utilizado para las operaciones de intercambio de seguridad de datos.
Con respecto al uso del tipo chan, primero mire las instrucciones en Qlang.
tipo chan
ch1 = make(chan bool, 2) // 得到 buffer = 2 的 chan bool
ch2 = make(chan int) // 得到 buffer = 0 的 chan int
ch3 = make(chan map[string]int) // 得到 buffer = 0 的 chan map[string]int
Similar al lenguaje Go, chan tiene las siguientes operaciones integradas:
n = len(ch1) // 取得chan当前的元素个数
m = cap(ch1) // 取得chan的容量
ch1 <- true // 向chan发送一个值
v = <-ch1 // 从chan取出一个值
close(ch1) // 关闭chan，被关闭的chan是不能写，但是还可以读(直到已经写入的值全部被取完为止)
Cabe señalar que después de cerrar chan, <-ch obtiene el valor indefinido. Entonces debería ser así en qlang:
v = <-ch1
if v != undefined { // 判断chan没有被关闭的逻辑
...
}
El uso más detallado se muestra en el siguiente ejemplo:
c = make(chan int)
go fn() {
for {
c <- 1
tk.SleepSeconds(1)
}
}()
go fn() {
for {
c <- 200
tk.SleepSeconds(1)
}
}()
go fn() {
for {
tmp = <-c
println(tmp)
tk.SleepMilliSeconds(500)
}
}()
for {
tk.SleepSeconds(5)
println("main thread")
}
En este fragmento de código, se crean 3 Goroutines, que pueden entenderse como 3 subprocesos. Los dos primeros subprocesos escriben datos en el canal cada segundo y el tercer subproceso escribe datos del canal cada 500 milisegundos. Leer un dato y mostrarlo. Además, no debemos olvidar el hilo principal, el hilo principal debe existir siempre, de lo contrario, todos los hilos secundarios saldrán con el final del hilo principal. Por lo tanto, tenemos un bucle infinito en nuestro hilo principal, generando información cada 5 segundos.
También tenga en cuenta que las tres Goroutines se ejecutan con go más una función anónima. El uso de go es el mismo que en el idioma Go, y otras funciones también se pueden iniciar como hilos.
Puede usar Ctrl-C para salir del programa, y el resultado de la ejecución completa del código es similar al siguiente (se repetirá indefinidamente hasta que presione Ctrl-C para terminar):
λ gox chan.gox
1
200
1
200
1
200
1
200
1
200
main thread
1
200
1
200
* Nota: Desde la versión 0.988, para reducir el tamaño de archivo innecesario, Gox ha abandonado otros motores de secuencias de comandos y solo es compatible con el motor Qlang, por lo que el siguiente contenido no es válido y solo está reservado para referencia a la versión anterior.
Y el siguiente es el uso de la versión del motor Anko, que es similar.
En primer lugar, es muy conveniente que cualquier función pueda iniciarse como un hilo con la palabra clave go; luego, el canal se puede definir de tal manera que make (chan string), el llamado canal en el lenguaje Go es la seguridad de concurrencia para compartir datos Para tipos de datos específicos, consulte la documentación oficial del idioma Go para conocer el uso específico.
El uso más detallado se muestra en el siguiente ejemplo:
tk = import("tk")
c = make(chan int64)
go func() {
for {
c <- 1
tk.SleepSeconds(1)
}
}()
go func() {
for {
c <- 200
tk.SleepSeconds(1)
}
}()
go func() {
for {
tmp = <-c
println(tmp)
tk.SleepMilliSeconds(500)
}
}()
for {
tk.SleepSeconds(5)
println("main thread")
}
En este fragmento de código, se crean 3 Goroutines, que pueden entenderse como 3 subprocesos. Los dos primeros subprocesos escriben datos en el canal cada segundo y el tercer subproceso escribe datos del canal cada 500 milisegundos. Leer un dato y mostrarlo. Además, no debemos olvidar el hilo principal, el hilo principal debe existir siempre, de lo contrario, todos los hilos secundarios saldrán con el final del hilo principal. Por lo tanto, tenemos un bucle infinito en nuestro hilo principal, generando información cada 5 segundos.
Puede usar Ctrl-C para salir del programa, y el resultado de la ejecución completa del código es similar al siguiente (se repetirá indefinidamente hasta que presione Ctrl-C para terminar):
λ gox scripts\chan.gox
1
200
1
200
1
200
1
200
1
200
main thread
1
200
1
200
1
200