Na linguagem Gox, ele basicamente herda o mecanismo de simultaneidade da linguagem Go e o tipo de canal chan usado para operações de compartilhamento de segurança de dados.
Em relação ao uso do tipo de canal, primeiro olhe as instruções em 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
Semelhante à linguagem Go, chan tem as seguintes operações integradas:
n = len(ch1) // 取得chan当前的元素个数
m = cap(ch1) // 取得chan的容量
ch1 <- true // 向chan发送一个值
v = <-ch1 // 从chan取出一个值
close(ch1) // 关闭chan，被关闭的chan是不能写，但是还可以读(直到已经写入的值全部被取完为止)
Deve-se notar que depois que chan é fechado, <-ch obtém o valor indefinido. Portanto, deve ser assim no qlang:
v = <-ch1
if v != undefined { // 判断chan没有被关闭的逻辑
...
}
O uso mais detalhado é mostrado no exemplo a seguir:
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")
}
Neste trecho de código, são criados 3 Goroutines, que podem ser entendidos como 3 threads.Os primeiros dois threads gravam dados no canal a cada segundo e o terceiro thread grava dados do canal a cada 500 milissegundos. Leia os dados e exiba-os. Além disso, não devemos esquecer o encadeamento principal, o encadeamento principal deve sempre existir, caso contrário, todos os encadeamentos filhos sairão com o fim do encadeamento principal. Portanto, temos um loop infinito em nossa thread principal, gerando informações a cada 5 segundos.
Observe também que os três Goroutines são executados com go mais uma função anônima. O uso de go é o mesmo que na linguagem Go, e outras funções também podem ser iniciadas como threads.
Você pode usar Ctrl-C para sair do programa e o resultado de toda a execução do código é semelhante ao seguinte (ele se repetirá indefinidamente até que você pressione Ctrl-C para encerrar):
λ gox chan.gox
1
200
1
200
1
200
1
200
1
200
main thread
1
200
1
200
* Observação: desde a versão 0.988, a fim de reduzir o tamanho desnecessário do arquivo, Gox abandonou outros mecanismos de script e só oferece suporte ao mecanismo Qlang, então o conteúdo a seguir não é mais válido e está reservado apenas para referência à versão antiga.
E o seguinte é o uso da versão do motor Anko, que é semelhante.
Em primeiro lugar, é muito conveniente que qualquer função possa ser iniciada como um thread com a palavra-chave go; então o canal pode ser definido como make (chan string), o chamado canal na linguagem Go é a segurança de simultaneidade para compartilhar dados Para tipos de dados específicos, consulte a documentação oficial do idioma Go para uso específico.
O uso mais detalhado é mostrado no exemplo a seguir:
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")
}
Neste trecho de código, são criados 3 Goroutines, que podem ser entendidos como 3 threads.Os primeiros dois threads gravam dados no canal a cada segundo e o terceiro thread grava dados do canal a cada 500 milissegundos. Leia os dados e exiba-os. Além disso, não devemos esquecer o encadeamento principal, o encadeamento principal deve sempre existir, caso contrário, todos os encadeamentos filhos sairão com o fim do encadeamento principal. Portanto, temos um loop infinito em nossa thread principal, gerando informações a cada 5 segundos.
Você pode usar Ctrl-C para sair do programa e o resultado de toda a execução do código é semelhante ao seguinte (ele se repetirá indefinidamente até que você pressione Ctrl-C para encerrar):
λ gox scripts\chan.gox
1
200
1
200
1
200
1
200
1
200
main thread
1
200
1
200
1
200