• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Linguagem Go
 

Linguagem Go

on

  • 1,278 views

 

Statistics

Views

Total Views
1,278
Views on SlideShare
1,278
Embed Views
0

Actions

Likes
0
Downloads
35
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Linguagem Go Linguagem Go Presentation Transcript

    • Paradigmas de Linguagens de Programação Delano Oliveira Janderson Jason Luan Barbosa Natã Melo {delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br
    • Agenda Introdução Valores e Tipos Armazenamento Associações Abstrações Unidades de Programa Sistemas de Tipos Sequenciadores Concorrência Conclusão PLP - Linguagem Go 2
    • Introdução
    • Introdução Motivação Sintaxe e Semântica Processador da Linguagem Outras Características PLP - Linguagem Go 4
    • Motivação Compilada Sensação de uma linguagem dinâmica Simula Orientação a Objetos Possui Garbage Collection Multi-processamento Open-source 18a linguagem mais usada no mundo segundo o site da Tiobe PLP - Linguagem Go 5
    • Sintaxe e Semântica Go reúne características sintáticas de várias linguagens Possui uma Sintaxe simples e intuitiva A sintaxe é descrita por uma Gramática (Extended Backus-Naur Form) Semântica Operacional PLP - Linguagem Go 6
    • Processador da Linguagem Compilador: gccgo (6g, 6l, 8g, 8l) Código Fonte *.8 ou *.6 Executável PLP - Linguagem Go 7
    • Outras Características Criada pela Google e lançada em novembro de 2009 Equipe: Robert Griesemer, Rob Pike e Ken Thompson PLP - Linguagem Go 8
    • Valores & Tipos
    • Valores & Tipos Valores  Tipos  Boolean  Primitivos  Numérico  Compostos  String  Recursivo  Array  Struct  Checagem de Tipos  Equivalência de Tipos  Ponteiros  Princípio da Completude  Abstração de função e  Expressões procedimento  Mapa  Channel PLP - Linguagem Go 10
    • Valores else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 11
    • Valores Númericos Arrays Abstração de Função else if (jogador_atual.GetCor() == Vermelho){ tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo, jogador_atual.GetCor()); if (LenArrayNode(tomadas) == 1){ if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) { contagemEmpate = 0; } RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y, tomadas[0], jogador_atual.GetCor(), true); } var posicao3 *Coordenada } Abstração de Procedimento Ponteiro Booleanos Em Go, abstrações de funções e procedimentos são valores de segunda classe. Funções podem ser passadas como parâmetros e retornadas como valor de função. PLP - Linguagem Go 12
    • Tipos Primitivos var barra string = "===== “ var contagemEmpate int = 0 var travou bool = false var porcentagem float = 10.5 Boolean – Representa o conjunto de valores booleanos Numeric – Representa o conjunto de valores inteiros ou valores de ponto- flutuante  uint(8, 16, 32, 64), int(8, 16, 32, 64), float(32, 64), complex(64, 128) String – Array de bytes. Imutável PLP - Linguagem Go 13
    • Tipos Compostos Produtos Cartesianos : Structs type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 14
    • Tipos Compostos Produtos Cartesianos : Structs [][]*Peca x int type Tabuleiro struct { matriz [8] [8] *Peca int totalPecas } Struct – Sequência de elementos.  Campos: possuem nome e tipo. Mapeamentos : Arrays, Mapas ou Funções resultado := map[string]int{"sao paulo" : 3, "corinthians" :0} Mapa – Grupo não ordenado de elementos. Possui Keys únicas. PLP - Linguagem Go 15
    • Tipos Compostos Tipos Recursivos: Structs type Node struct { valor Tupla next *Node }  Implementados através de ponteiros. Go não dá suporte:  União Disjunta  Conjuntos Potência PLP - Linguagem Go 16
    • Checagem de Tipos Go é estaticamente e fortemente tipada. func main (){ var nome string = "plp" nome = 18 } prog.go:6: cannot convert 18 to type string prog.go:6: cannot use 18 (type int) as type string in assignment func main (){ Erro ao tentar Fortemente dez_decimal := 10.0 var dez int = dez_decimal compilar!!! } prog.go:6: cannot use dez_decimal (type float) as type int in assignment PLP - Linguagem Go 17
    • Equivalência de Tipos Go dá suporte a equivalência nominal package main type Peca struct {cor int, dama bool} type Tupla struct {tamanho int,comida bool} func (peca *Peca) EhDama () (bool){ return peca.dama } func main (){ var tupla *Tupla = new(Tupla) Erro ao tentar tupla.EhDama() compilar!!! } prog.go:15: tupla.EhDama undefined (type Tupla has no field EhDama) Go não dá suporte a equivalência estrutural! PLP - Linguagem Go 18
    • Princípio da Completude Go quebra o princípio da completude de tipo.  É necessário o uso do tipo File para manipular arquivos persistentes.  Funções só podem retornar valores primitivos ou ponteiros. func (tabuleiro *Tabuleiro) IsZerou (cor int) bool if (…){ return false } return true } PLP - Linguagem Go 19
    • Expressões Literais: Valores dos tipos bool, int, uint, float, string Agregados: array, maps, structs Funções Go não dá suporte a:  Expressões Condicionais  Expressões Iterativas PLP - Linguagem Go 20
    • Armazenamento
    • Armazenamento Variáveis e Atualização  Tipos de Comandos Arrays  Skip Semântica de Cópia x  Atribuição Semântica de Referência  Chamada de Variáveis procedimento  Locais e Globais  Comandos  Heap  Sequencial  Persistentes  Colateral  Condicional  Expressões com Efeitos Colaterais PLP - Linguagem Go 22
    • Variáveis e Atualização Os valores armazenáveis (storables) são os valores dos tipos primitivos e ponteiros Variáveis Temporárias  Todas as variáveis, com exceção do tipo File Variáveis Persistentes  Em Go, as variáveis persistentes são do tipo File PLP - Linguagem Go 23
    • Variáveis e Atualização Go dá suporte a atualização seletiva e atualização total var posicaoFinal Coordenada; Seletiva posicaoFinal.x = 1; posicaoFinal.y = 2; var posicaoInicial Coordenada; Total posicaoInicial = posicaoFinal; PLP - Linguagem Go 24
    • Arrays Go dá suporte a Arrays Estáticos. Os arrays possuem tamanho fixo e não podem armazenar valores de tipos diferentes. func (tabuleiro *Tabuleiro) GetPecas (cor int) ([12]*Tupla){ var pecas [12] *Tupla; (...) return pecas; } PLP - Linguagem Go 25
    • Semântica de Cópia x Semântica de Referência Semântica de cópia – utilizada para valores de qualquer tipo. Semântica de Referência – utilizada apenas para ponteiros. var posicao1 Coordenada; posicao1.x = 1; posicao1.y = 2; var posicao2 *Coordenada; var posicao3 *Coordenada; Por Referência posicao2 = &posicao1; posicao3 = posicao2; posicao3.x = 5; posicao3.y = 5; Por Cópia PLP - Linguagem Go 26
    • Variáveis Locais e Globais Variáveis Globais são declaradas da seguinte forma: var + nomeVariavel + tipo Para variáveis locais podem ser utilizados açúcares sintático var jogadorDaVez string = “tabuleiro” Variável Global func main() { tamanho := 10; Açúcar if (...){ Variáveis LocaisSintático var numBombas = 15; } } PLP - Linguagem Go 27
    • Variáveis Heap Variáveis podem ser declaradas a partir da palavra reservada new. Não existe um mecanismo para o programador destruir as variáveis. Go possui Garbage Collection. Alocação de memória var tabuleiro_jogo *Tabuleiro = new (Tabuleiro) PLP - Linguagem Go 28
    • Variáveis persistentes São do tipo “File” oldfile := "text.txt" newfile := "text2.txt" doc, _ := ioutil.ReadFile(oldfile) ioutil.WriteFile(newfile,doc,0644) PLP - Linguagem Go 29
    • Skip e Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Não há atribuição múltipla em Go. PLP - Linguagem Go 30
    • Skip e Atribuição Skip usado para separar expressões Atribuição for ; pilha != nil ; { tabTemp := tabuleiro.Copy() pilha, tuplaAtual = pilha.Pull() tabTemp.ComerPeca(posX, posY, tuplaAtual, cor) caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp, tuplaAtual.FicarX, tuplaAtual.FicarY, cor) tamanhoCaminhoTupla++ Açúcar sintático Atribuição simultânea Não há atribuição múltipla em Go. PLP - Linguagem Go 31
    • Chamada de Procedimentos Chamada de procedimento peca := new (Peca) peca.SetCor(Preto) //... func (peca *Peca) SetCor (cor int) { peca.cor = cor } Procedimento PLP - Linguagem Go 32
    • Comando Sequencial meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; meuTabuleiro.n = 0 Separados por ponto-e-vírgula, meuTabuleiro.m = 0 ou por quebra de linha. meuTabuleiro.ganhou = falseComando Colateral Não existem comandos colaterais. PLP - Linguagem Go 33
    • Comando Condicional Go dá suporte através de: if ,else e switch. var jogada int; if (ehHumano) { var pos [2]int = JogarHumano(); jogada = tabuleiro.Jogada(pos); } else { var pos [2]int = JogarAutomatico(); jogada = tabuleiro.Jogada(pos); } var aux string; switch opcao{ case 1: aux = "Jogar“ case 2: aux = "Ajuda" case 3: aux = "Fechar" } PLP - Linguagem Go 34
    • Comandos Iterativos Iteração definida for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS; i++ { nodeAtual = new(Node); nodeAtual.SetValor(tuplaAtual); //... } Iteração indefinida Palavra reservada for for i > 0 { funcionando como o var a int = Random(n); comando while em var b int = Random(n); outras linguagens. //... } PLP - Linguagem Go 35
    • Associações
    • Associações Entidades Associáveis  Comando Bloco Escopo  Expressão Bloco Estrutura de Blocos  Princípio da Qualificação Visibilidade Declarações  Definição  Declaração de Tipo  Declaração de Variável  Declarações Colaterais  Declarações Sequenciais  Declarações Recursivas PLP - Linguagem Go 37
    • Entidades Associáveis Valores primitivos e compostos Abstrações de funções e procedimentos Variáveis e Tipos meuTabuleiro.m = 0; meuTabuleiro.ganhou = false; var Numero int = calculaNumDeMinas(n); const( MAX_MOVIMENTOS int = 50); PLP - Linguagem Go 38
    • Escopo const s = 2; func incremento ( d int ) int { return d∗s; } func executaIncremento ( valor int ) int { const s = 3; return incremento ( valor ); } Saída: 10 func main () { fmt.Println( executaIncremento(5) ); } Em Go, o corpo de um bloco é avaliado no ambiente em que foi definido (associação estática). PLP - Linguagem Go 39
    • Blocos: Estrutura e Visibilidade var tamanhoTabuleiro int = 10; for { var tamanhoTabuleiro = 15; for { var tamanhoTabuleiro = 20; imprime 20 fmt.Println( tamanhoTabuleiro ); break; } imprime 15 fmt.Println( tamanhoTabuleiro ) ; break; } imprime 10 fmt.Println( tamanhoTabuleiro ); Estrutura: blocos aninhados. Visibilidade: variáveis declaradas em blocos de escopo internos não são visíveis a blocos de escopo externos. PLP - Linguagem Go 40
    • Definição As definições em Go podem ser de tipo, abstração de funções, abstração de procedimentos, variáveis, constantes. const( MAX_MOVIMENTOS int = 50) func Jogada() (int,int) { //… } Constante var posJogada; var posX *int; Abstração de função var posAux *int; Variáveis PLP - Linguagem Go 41
    • Declaração de Tipo type Peca struct {  Go dá suporte a declaração de tipos cor int; dama bool; através da palavra reservada type. } O tipo Peca sendo declarado.Declaração de Variável var vertical string = "Coordenada Vertical: “; var valor int = 1; var decimal float = 1.0; PLP - Linguagem Go 42
    • Declaração sequencial  Como a maioria das linguagens imperativas, Go dá suporte à declaração sequencial. tamanhoMaiorCaminho := 0; tamanhoCaminhoTupla := 0; var pilha *Node = nil; var caminhoAtual [MAXIMO_CAMINHOS] *Node;Declarações Colaterais Go não dá suporte a este tipo de declaração. PLP - Linguagem Go 43
    • Declaração recursiva  Go dá suporte a declaração recursiva.func TomadaMaximaPeca(tabuleiro *Tabuleiro, posX int, posY int, cor int)([MAXIMO_CAMINHOS] *Node, int) { caminhos := tabuleiro.GetOpcoesComida(posX, posY, cor); for ;pilha != nil; { caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp,tuplaAtual.FicarX, tuplaAtual.FicarY, cor); return caminhosMaximos, tamanhoMaiorCaminho;} Chamada recursiva PLP - Linguagem Go 44
    • Comando bloco Go dá suporte a comando bloco. func ( pilha ∗Node ) PrintValorProximo( ) { Println ( "|" , pilha.GetValor( ) , "|" ); next := pilha.GetNext( ); Println(next.GetValor()); } Declaração que é usada apenas pra executar o comando PLP - Linguagem Go 45
    • Expressão bloco Go dá suporte a expressão bloco. func (peca *Peca) GetValue(peca2 *Peca)(bool){ valor1 := peca.EhDama() valor2 := peca2.EhDama() return valor1 && valor2 } Declarações usadas apenas para avaliar a expressão. PLP - Linguagem Go 46
    • Princípio da Qualificação Go não viola o princípio da qualificação, pois é possível realizar qualquer computação dentro de um bloco. func (pilha *Node) GetNext() (*Node, *Tupla){ next := pilha.GetNext() valor := next.GetValor() func nome(){ //Corpo da funcao } return next, valor } Um bloco dentro do outro. PLP - Linguagem Go 47
    • Abstrações
    • Abstrações Tipos de Abstrações  Argumentos  Abstração de Função  Passagem de Parâmetros  Abstração de  Princípio da Procedimento Correspondência  Ordem de Avaliação Princípio da Abstração Parâmetros PLP - Linguagem Go 49
    • Abstração de Função Go dá suporte a abstrações de funções através da palavra reservada func. A presença do retorno caracteriza a abstração de função. func calculaNumDeMinas(tamanho int) int{ numeroDeBombas := int(tamanho*tamanho*20/100); if (numeroDeBombas%2 == 0) { numeroDeBombas += 1; } //m sempre impar if (tamanho <= 10) { numeroDeBombas += 2; } return numeroDeBombas; } PLP - Linguagem Go 50
    • Abstração de Procedimento Go usa a mesma palavra reservada para caracterizar uma Abstração de Procedimento, como em Abstrações de Funções. (func) A diferença que caracteriza a Abstração de Procedimento é a falta do retorno. func inicializarJogo() { tabuleiro.ReiniciaTabuleiro(); ehHumano = true; } PLP - Linguagem Go 51
    • Princípio da abstração  Go não viola o princípio da abstração, pois é possível construir abstração sobre qualquer categoria sintática da linguagem, como por exemplo: variáveis, funções e procedimentos. PLP - Linguagem Go 52
    • Parâmetros Como Go é fortemente tipada, os parâmetros devem possuir tipos definidos. Podem ser de qualquer tipo. type Peca struct { cor int dama bool } func (peca *Peca) EhDama () (bool){ return peca.dama } PLP - Linguagem Go 53
    • Passagem de Parâmetros Em Go a passagem de parâmetros é por cópiavalor. func Inverter (i int) int { if(i != 0) { return 0 } return 1 } Go não dá suporte a passagem de parâmetros por referência, mas simula com o uso de ponteiros. func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() } Ponteiro PLP - Linguagem Go 54
    • Princípio da Correspondência Go viola o princípio da correspondência, pois não existe um mecanismo de passagem de parâmetro correspondente a definição de constante. Código abaixo não é compilável.const constante = 10;func funcao ( c const ) const { return c ;}func main ( ) { fmt.Println ("Imprimir constante:" , funcao ( constante ) ) ;} Dá erro de sintaxe PLP - Linguagem Go 55
    • Ordem de Avaliação  Eager Evaluation var p int; func main () { p = 3; print ( p ) } Saída: func print ( n int ) { Println(n); 3 p = 100; 3 Println(n); } PLP - Linguagem Go 56
    • Unidades de Programa
    • Unidades de Programa Pacotes Tipos Abstratos de Dados Objetos e Classes Unidades Genéricas PLP - Linguagem Go 58
    • Pacotes As funções e variáveis globais que começam com letra Maiúscula serão visíveis para quem importar esse pacote. Caso contrário, a função fica com visibilidade privada.package tabuleiro//...func (meuTabuleiro *Tabuleiro) Ganhou() bool { return meuTabuleiro.ganhou;} Funções visíveisfunc (meuTabuleiro *Tabuleiro) AlguemGanhou(){ meuTabuleiro.ganhou = true;}func calculaNumDeMinas(tamanho int) int{ //... Função com return numeroDeBombas; visibilidade privada}/ PLP - Linguagem Go 59
    • Tipo Abstrato de Dados package tabuleiro import (. "fmt"; . "./pecaPkg"; . "./util") type Tabuleiro struct {matriz [8] [8] *Peca} func (tabuleiro *Tabuleiro) SetPecaDama (x int, y int){ tabuleiro.matriz[x][y].SetDama(true) } //... PLP - Linguagem Go 60
    • Objetos e Classes  Go não tem Objetos e Classes, porém, simula-os através de structs e funções ligadas a esses tipos. type Node struct { valor Tupla next *Node } //... func (pilha *Node) Pull() (*Node, *Tupla) { return pilha.GetNext(), pilha.GetValor() }Unidades Genéricas  Go não dá suporte a unidades genéricas. PLP - Linguagem Go 61
    • Sistemas de Tipos
    • Sistema de Tipos Monomorfismo Sobrecarga Polimorfismo Paramétrico Polimorfismo por Inclusão Interfaces Coerção PLP - Linguagem Go 63
    • Monomorfismofunc (meuTabuleiro *Tabuleiro) Ganhou() bool{ return meuTabuleiro.ganhou;}func (meuTabuleiro *Tabuleiro) AlguemGanhou() { meuTabuleiro.ganhou = true; As abstrações definidas pelo} programador, em Go, são monomórficas. Toda entidade tem um tipo específico associado.Println("---------------------------");Print("Linha: ");Println(posMaquina[0]+1);Print("Coluna: ");Println(posMaquina[1]+1); Mas, algumas abstraçõesPrintln("---------------------------"); embutidas (built-in) não são monomórficas. PLP - Linguagem Go 64
    • Sobrecarga Go dá suporte a sobrecarga de operadores built-in. Entretanto, não dá suporte a sobrecarga de operaçoes. (Operadores: +, -, e outros)var barra string = "===== “;//...if (tabuleiro_jogo.IsZerou (jogador1.GetCor())){ Println(barra + "Jogador", jogador2.GetCor() + 1, "VENCEU! PARABÉNS", barra); break;}//... Para tipos da própria linguagem, um único identificador ou operador pode denotar diferentes abstrações. PLP - Linguagem Go 65
    • Polimorfismo por Inclusão type Natural int; type Inteiro int; var x Natural = 1; var y Inteiro = -1; Println(x+y); //input.go:10: invalid operation: x + y (type Natural + Inteiro) Go não tem tipos que contenham subtipos que herdam operações aplicáveis a valores desses tipos. PLP - Linguagem Go 66
    • Polimorfismo Paramétricofunc polimorfismoParametrico(a int64, b int64) { Println(a); Println(b);}func main() { var x int8 = 1; var y int8 = 2; polimorfismoParametrico(x, y);}//input.go:13: cannot use x (type int8) as type int64 in function argument//input.go:13: cannot use y (type int8) as type int64 in function argument Go não dá suporte a polimorfismo paramétrico. PLP - Linguagem Go 67
    • Interfacepackage mainimport . "fmt";func main(){ jogador := new(Jogador); jogador.nome = "iza";  Go simula peca := new(Peca); peca.cor = "preto"; o uso de imprimir(jogador); imprimir(peca); interface} com o tipotype printer interface { Print(); } “interface”.func (p *Peca) Print() { Println(p.cor); }func (j *Jogador) Print() { Println(j.nome); }func imprimir (p printer) { p.Print(); }type Peca struct { cor string; }type Jogador struct { nome string; } PLP - Linguagem Go 68
    • Coersãofunc Random(n int) int { sec, nsec, err := Time(); if err != nil { Seed(int64(n)); } else { Seed(int64(n)+(sec*1e9+nsec)); } return int(Int63n(int64(n)))} Não há mapeamento implícito de valores de um tipo para valores de um outro tipo. Em substituição às coerções, são adotados casts. PLP - Linguagem Go 69
    • Sequenciadores
    • Sequenciadores Desvios Incondicionais Escapes Exceções PLP - Linguagem Go 71
    • Desvios Incondicionais I: Println(“Digite a dimensao: (N)"); var tam int = ReadInt(); if ( tam < 20 && tam > 4) { goto L; } Println(“N fora do limite [4,20]."); goto I; L: geraTabuleiro(tam); Para fazer Desvios Incondicionais usamos a palavra reservada “goto”  Só podemos fazer desvios incondicionais dentro do escopo da abstração de função. (Não podemos ir para pontos mais externos do programa). PLP - Linguagem Go 72
    • Escapefor i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { Iteração afetada if (tabuleiro[i][j] == 9) { pelo escape Println("Achou bomba na linha ", i+1); break; } }}  Go dá suporte a escape através da palavra reservada“break” e “continue”.  Escape não rotulado apenas finaliza a iteração corrente. PLP - Linguagem Go 73
    • Escape rotulado busca: for i := 0; i < len(tabuleiro); i++ { for j := 0; j < len(tabuleiro[i]); j++ { if (tabuleiro[i][j] == 9) { Println("Achou bomba na linha ", i+1); break busca; } } } Rótulo  Go dá suporte a escape rotulado através da palavra reservada break mais o rótulo. PLP - Linguagem Go 74
    • Exceções  Go não dá suporte a exceções. PLP - Linguagem Go 75
    • Concorrência
    • Concorrênciavar canal = make(chan int);func main() { go rotina1(); go rotina2(); Channel}func rotina1(){ Goroutines var i int = 0; for i = 0; i <= 100; i++ {  Go dá suporte a concorrência canal <- i; através de goroutines. }}  A comunicação entre osfunc rotina2(){ processos concorrentes é for { através de channel. msg := <- canal; Println(msg); if(msg == 100){ break; } }} PLP - Linguagem Go 77
    • Spin-Lockfunc acquire(){ for(usandoRecurso){ } usandoRecurso = true; Flag}func relinquish(){ usandoRecurso = false;}  O flag é uma variável global.  Assim permitimos que apenas umafunc rotina1(){ acquire(); rotina tenha acesso ao recurso. //regiao critica relinquish(); Rotinas}func rotina2(){ acquire(); //regiao critica relinquish();} PLP - Linguagem Go 78
    • Conclusão
    • PLP - Linguagem Go 80
    • PLP - Linguagem Go 81
    • Referências
    • Referências http://alovasconcelos.net/ http://golang.org http://tutorial.danielmazza.info/go RAMALHO, Franklin. Notas de Aula da disciplina Paradigmas de Linguagens de Programação, 2010. http://forum.zwame.pt/showthread.php?t=348920 PLP - Linguagem Go 83