tudo pronto
[3hU9fRjo95.git] / relatorio.txt
blob9a55a30fc4108373d85e070d512621058841f5ef
1 Golang\r
2         Instalação:
3                 cd ~
4                 gedit .bashrc &
5                         colar no final:
6                                 export GOROOT=$HOME/go
7                                 export GOARCH=386
8                                 export GOOS=linux
9                         reiniciar o shell
10                         sudo apt-get install bison gcc libc6-dev ed gawk make
11                         sudo apt-get install python-setuptools python-dev build-essential gcc
12                         sudo easy_install mercurial
13                         hg clone -r release https://go.googlecode.com/hg/ $GOROOT
14                         cd $GOROOT/src
15                         mkdir $HOME/bin
16                         ./all.bash
17                         cd $HOME/bin
18                         sudo mv * /bin\r
19         Uso:
20                 editor de texto -> prog.go
21                 8g prog.go -> prog.8
22                 8l -o prog prog.8 -> prog
23                 ./prog \r
25 Mecanismos de Programação Concorrente:
26   Channel:
27                 Representa um cana de comunicação / sincronização que pode conectar duas computações concorrentes. Na realidade são referências para um objeto que coordena a comunicação.
28                 <- é o operador binário de comunicação (envio)
29                 <- também é o operador, desta vez unário, de recebimento
30                 ambos são atômicos
31                 Operações em canais bloqueiam, então se não houver receptor para uma mensagem, a operação de envio espera até que algum apareça.
32                 pode ser receive_only (<-chan) e send_only (chan<-). Tod canais são criados bidirecionais, a utilidade disso é para os argumentos dos funções para garantir que ele só vai ler (respectivamente escrever) no canal.
33                 um canal asíncrono com buffer é criado passando o número de elementos no buffer para o make (c := make(chan int, 50)).
34                 para testar comunicabilidade:
35                 ok := c <- v;
36                 v, ok = <-c;
37                 um channel com buffer pode ser usado como um semáforo
39         Goroutines:
40                 Go tem seu próprio modelo de processo/thread/processo leve/corotinas, chamado goroutines. No gccgo são implementadas com pthreads, mas no 6g não. São divididas de acordo com o necessário em threads do sistema. Quando uma goroutine executa uma chamada de sistema bloqueane, nenhuma outra goroutine é bloqueada.
41                 $GOMAXPROCS ou runtime.GOMAXPROCS(n) dizem quantas goroutines não bloqueantes entre si o sistema pode executar ao mesmo tempo.
43         go:
44                 é o operador que inicia a execução concorrente de uma goroutine no mesmo espaço de endereçamento.
45                 Prefixe uma chamada de função ou de método com a palavra-chave go para executar a chamada numa nova gorotina. Quando a chamada termina, a gorotina também termina (silenciosamente). O efeito é similar a notação & do shell Unix para rodar um comando em background.
47         select:
48                 é um estrutura de controle análoga a um switch de comunicações. Cada caso deve ser um send ou receive. escolhe qual das comunicações listadas em seus casos pode prosseguir. Se todas estão bloqueadas, ele espera até que alguma desbloqueie. Se várias podem prosseguir, ele escolhe uma aleatoriamente.
49                 sumário:
50                         todos os casos devem ser uma comunicação
51                         todas as expressões com canal são avaliadas
52                         todas as expressões a serem enviadas são avaliadas
53                         se qualquer comunicação pode prosseguir, ela o faz, e as outras são ignoradas
54                         caso contrário:
55                                 se há uma cláusula default, ela executa
56                                 se não há default, o select bloqueia até que alguma comunicação possa prosseguir. não há re-avaliação de canais ou valores
57                         se várias cláusulas estão prontas, uma é escolhida aleatoriamente, de maneira justa, e as outras não executam.
58                         random bit generator
59                                 for {
60                                         select {
61                                         case c <- 0:
62                                         case c <- 1:
63                                         }
64                                 }
67         defer executa uma função apenas quando a função que o chama retorna. Útil para destrancar mutexes.
69         Filosofia: "não comunique compartilhando memória. Em vez disso, compartilhe memória comunicando-se." O simples ato de comunicação garante a sincronização.
71         Concorrência em muitos ambientes se torna difícil pelas sutilezas envolvidas no acesso correto a variáveis compartilhadas. Go encoraja uma abordagem diferente, na qual variáveis compartilhadas são passadas através de canais e nunca são de fato ativamente compartilhadas por threads de execução separadas. Apenas uma gorotina tem acesso à variável num dado momento de tempo. Condições de corrida relativas aos dados não podem ocorrer, por construção.
73         concorrência inspirada no CSP.
75         Exclusão Mútua:\r
76                 Criação:\r
77                 Uso:\r
78                 Destruição:\r
79                 Implementação:\r
80                         Problema produtor-consumidor com buffer limitado e taxa de \r
81         produção e consumo aleatórias.\r
82         Semáforos:\r
83                 Criação:\r
84                 Uso:\r
85                 Destruição:\r
86                 Implementação:\r
87                         Problema produtor-consumidor com buffer limitado e taxa de \r
88         produção e consumo aleatórias.\r
89         Monitores:\r
90                 Criação:\r
91                 Uso:\r
92                 Destruição:\r
93                 Implementação:\r
94                         Problema produtor-consumidor com buffer limitado e taxa de \r
95         produção e consumo aleatórias.\r
96         Variáveis de Condição:\r
97                 Criação:\r
98                 Uso:\r
99                 Destruição:\r
100                 Implementação:\r
101                         Problema produtor-consumidor com buffer limitado e taxa de \r
102         produção e consumo aleatórias.\r
104 Processos, Threads ou Ambos?
105         
106 Funções Úteis:
107         time.Sleep(int)
108         func init()
109         http://golang.org/pkg/sync/
110         http://golang.org/doc/go_mem.html