Um dos aspectos mais populares da linguagem de programação Go é o seu apoio de primeira classe à capacidade de um computador para realizar muitas tarefas em simultâneo. A capacidade de executar código simultaneamente está a tornar-se mais importante na programação à medida que os computadores passam da execução de um único fluxo de código mais rápido para a execução simultânea de muitos fluxos. Para tornar os programas que correm mais rapidamente, os programadores devem projectá-los para correr simultaneamente, de modo a que cada elemento concorrente do sistema possa executar independentemente dos outros.
Duas Go funcionalidades, Goroutines, e canais tornam a simultaneidade mais fácil quando utilizados em conjunto. Goroutines oferecem o tipo primário básico para esta capacidade. Goroutines são menos dispendiosos no que diz respeito ao espaço de memória, interacção entre fios, e conectividade de rede. Têm também um melhor tempo de arranque do que os threads, que muitas linguagens de programação suportam. Na sua essência, Go refere-se a Goroutines como aquilo a que Java e outras linguagens de programação se referem como threads.
O que são Goroutines?
Um goroutine é um simples fio de implementação no Golang que funciona simultaneamente com o resto do programa. Goroutines são acessíveis quando se assemelham a fios padrão, uma vez que o custo de criar um goroutine é extremamente baixo. Por conseguinte, são amplamente utilizados em Go para programação concorrente. Cada programa consiste em pelo menos um único goroutine conhecido como o goroutine principal. O goroutino principal controla todos os outros goruínos; assim, se o goroutino principal terminar, todos os outros goruínos do guião também o fazem. O goroutino está sempre activo no fundo.
Exemplo: Aqui está uma ilustração: está a escrever algo no seu caderno e a ficar com fome; fará uma pausa e receberá alguma comida. Depois comece a escrever novamente. Agora está a desempenhar dois papéis (escrever e comer) por uma janela de tempo considerada como um emprego concorrente. É de salientar que estas duas tarefas (escrever e comer) ainda precisam de ser concluídas concomitantemente. Quando as tarefas são concluídas simultaneamente, é referido como paralelismo (imagine usar o seu telemóvel enquanto come batatas fritas). O paralelismo inclui a interacção com muitas coisas em simultâneo. O paralelismo (realizar muitas coisas simultaneamente) é uma subclasse disto (não tem de ser realizado ao mesmo tempo) com algum horário.
Podemos adicionar um goroutine aplicando a palavra-chave go à chamada de função. Assim que aplicarmos a palavra-chave go à chamada de função, definiremos a concordância com a execução. Mas primeiro, vamos identificar o efeito da aplicação da palavra-chave go à execução. Vamos considerar que há dois goroutinos num programa. O texto "package main import" será a entrada do programa. Em Go, um pacote de importação principal é uma declaração de importação declarativa. O goroutino principal (first goroutine) está implícito. Quando executamos go (f), forma-se o segundo goroutino (0). Normalmente, o nosso software executará cada comando na função principal quando executamos uma função antes de passarmos à linha seguinte.
Podemos executar o procedimento rapidamente com um goroutine antes de passarmos à etapa seguinte. Como resultado, foi adicionado um método scanln; caso contrário, o código terminaria antes de mostrar todos os números. Goroutines são simples de criar e podem ser feitos em grandes números. Notará que quando este software é executado, os goruínos parecem funcionar sequencialmente e não concomitantemente.
Vantagens do Goroutines sobre os fios
Goroutines custa pouco
Goroutines são menos caros do que outros processos. O tamanho da massa é de apenas alguns kilobytes, e pode expandir-se ou contrair-se para satisfazer as exigências do programa, por oposição aos fios, cujo tamanho da pilha deve ser definido e é permanente.
Existem multiplexados Goroutines
Há muito poucos fios do sistema operativo aos quais estão multiplexados. Num programa com centenas de goroutinos, pode haver apenas um processo. O resto dos goroutinos são transferidos para o novo processo do sistema operativo. Suponha-se que qualquer goruíno nesse processo fica preso, por exemplo, quando procura a intervenção do utilizador. O tempo de execução gere cada um destes, e a nós, criadores, é-nos dado um API claro para gerir simultaneamente, enquanto estamos isolados destas complexidades subtis.
Goroutines comunicar utilizando canais
Goroutines conversar através de canais. Destinados a prevenir a ocorrência de situações raciais quando partilham memória relevante. Os canais podem ser comparados a um canal que os goroutinos utilizam para interagir.
O que são canais?
Dois goroutinos podem interagir um com o outro e coordenar o seu funcionamento através de canais. Este software irá imprimir continuamente "ping". Para designar um formulário de canal, o prefixo "chan" é acompanhado pelos itens transmitidos no canal". Neste caso, estamos a fornecer cordas. No canal, as mensagens são enviadas e recebidas utilizando o operador. "ping" refere-se ao envio de um "ping".
Um canal é utilizado para manter os dois goroutinos em sincronia. Antes de tentar enviar uma mensagem através do canal, o router esperará até que a impressora esteja pronta para a aceitar. O termo para isto é inibição. Ao criar um canal, um segundo parâmetro pode ser utilizado para a função make: c:= make (chan int, 1)
A direcção do canal
Podemos definir a orientação e os parâmetros de um formulário de canal a receber ou a transmitir. O sinal do método Pinger, por exemplo, pode ser alterado para tal:
func pinger(c chan<- string)
C só pode ser enviado agora. A recepção a partir de c resultará num erro de código. Da mesma forma, podemos modificar a saída para:
func printer(c string -chan)
Um semi-canal não tem estas restrições. Um canal bidireccional pode ser fornecido a um procedimento que só aceita canais de transmissão ou apenas de aceitação, mas não o contrário.
Como fazer um Goroutine?
O método de lançamento de um Goroutine é simples. Aplique a palavra-chave "go" à chamada de função para fazer um Goroutine que será executado simultaneamente. Aqui vamos fazer um goroutine. Vamos supor que temos um programa contendo duas funções: uma é uma função bem-vinda, e a outra é a função principal.
Quando criamos um novo goroutine, o código de boas-vindas () será executado juntamente com a função principal(). Quando se executa este programa, fica-se surpreendido. Este programa apenas mostra o texto da operação principal. O que aconteceu ao primeiro goroutine ou ao novo goroutine que iniciámos? Para compreender porque é que isto ocorre, temos primeiro de conhecer as duas principais características dos goroutinos.
- A função goroutina responde instantaneamente quando criamos um novo goroutino. Para além das funções, a gestão não depende do goroutino, pelo que não espera que este complete a sua execução. A execução é entregue ao seguinte bloco de código após a função de goroutino. É por isso que qualquer dado parâmetro do goroutine é ignorado.
- Qualquer gorutim extra deve ser executado em simultâneo com o goroutino primário. Se o goroutino principal falhar, o programa desistirá, e nenhum gorutim adicional será executado.
Compreende agora porque é que o nosso código não funcionou. Na sequência da chamada para ser bem-vindo(), o controlo foi transferido para a seguinte linha de código antes de esperar que o "olá goroutine" completasse, e a função principal foi emitida. O goroutine principal morreu porque não havia nenhum script para executar, impedindo que o "olá Goroutine" funcionasse.
Invocámos a técnica do sono (time.sleep(1 * time.second)) para pausar o goroutine durante 1 segundo. A função de saudação () tem agora tempo suficiente para ser concluída antes da saída do goroutine principal. Este software escreve inicialmente o "welcome goroutine" e depois espera um segundo antes de imprimir a função principal. Utilizamos a técnica do sono no goroutino principal para o interromper por um momento a fim de deixar os outros goruínos completarem.
Criação de múltiplos Goroutines
Vamos iniciar outro programa para criar múltiplos goroutinos. Podemos começar por criar dois goroutinos que serão executados em paralelo. Estes dois goroutinos são números goroutinos[go números()] e goroutinos alfabéticos [go alphabets ()].
O número goroutino fica durante 250 ms antes de imprimir 1, descansa novamente antes de imprimir 2, e assim sucessivamente até produzir 5. Da mesma forma, o goroutino alfanumérico exibe a letra de a a e e, em seguida, espera 400 milissegundos. Finalmente, o goroutine primário cria os números inteiros e alfanuméricos e faz uma pausa para uma espiada, e depois o goroutine principal termina.
Erros frequentes de programação concomitante
- Ausência de sincronizações quando tal é necessário
- Usar o tempo. Chamadas para dormir para fazer sincronizações
- Deixar os goroutinos pendurados valores de cópia dos tipos no pacote de sincronização padrão
- Chamar a sincronia
- Waitgroup
- Acrescentar método em locais errados
- Utilizar canais como canais próximos de amanhã, não do último goroutine remetente funcional
Conclusão
Neste artigo, desenvolvemos um programa que utilizou a palavra-chave go para lançar um goroutine e vários goroutinos que imprimiam simultaneamente inteiros. Depois de iniciarmos esse programa, estabelecemos um novo canal, que depois utilizámos para produzir números num goroutine e passá-los para outro goroutine para que pudessem ser exibidos no ecrã. Como demonstração final de como iniciar um goroutino para acelerar as suas aplicações em sistemas multi-core, lançou simultaneamente muitos goroutinos "impressos".
Como sabemos, os goroutinos são uma forma de executar tarefas de forma mais rápida e eficiente. Este é um dos procedimentos de implantação oferecidos por AppMaster para melhorar a funcionalidade da sua aplicação. Com AppMaster, mesmo pessoas com pouco ou nenhum conhecimento de programação podem completar tarefas que seriam um desafio para completar através da codificação manual.
AppMaster é uma no-code plataforma que é capaz de criar aplicações móveis e web , assim como um backend. Um facto interessante AppMaster cria um backend por Go a 22.000 linhas por segundo e é possível aceder ao código fonte.
