data/pages/languages/go.txt

   1 ====== Go ======
   2
   3 [[http://golang.org/|Go]]: [[wp>Go_(programming_language)|Go]]
   4
   5 ===== Examples =====
   6
   7 <file make makefile>
   8 PROG = prog_name
   9
  10 all: $(PROG)
  11
  12 %: %.8
  13         8l -o $@ $<
  14
  15 %.8: %.go
  16         8g $<
  17 </file>
  18
  19 <file c hello.go>
  20 /* hello */
  21
  22 package main // executável principal sempre deve pertencer a este pacote
  23
  24 import . "fmt" // importa funções de saída formatada (Printf)
  25
  26 // função principal (como em C)
  27 func main() {
  28         //sem o . no import teríamos que utilizar fmt.Printf
  29         Printf("hello, world\n")
  30 }
  31 </file>
  32
  33 <file c producer_consumer.go>
  34 /* pc_channel_multi.go */
  35
  36 package main
  37
  38 import (
  39         . "fmt"
  40         "crypto/rand"
  41         "time"
  42         "flag"
  43 )
  44
  45 func random_between (begin, end int64) int64 {
  46         random_byte := make([]byte, 1)
  47         rand.Read(random_byte)
  48         return int64(random_byte[0]) % (end - begin + 1) + begin
  49 }
  50
  51 func random_sleep () {
  52         time.Sleep(random_between(0, *MAX_SLEEP_TIME) * 10e7)
  53 }
  54
  55 func send (channel chan int, i int) {
  56         channel <- i
  57 }
  58
  59 func recv (channel chan int) int {
  60         return <-channel
  61 }
  62
  63 func signal (channel chan int) {
  64         if len(channel) < cap(channel) || cap(channel) == 0 {
  65                 channel <- 0
  66         }
  67 }
  68
  69 func wait (channel chan int) {
  70         <-channel
  71 }
  72
  73 var (
  74         BUFFER_SIZE = flag.Int("s", 5, "BUFFER_SIZE") // flag -s
  75         MAX_SLEEP_TIME = flag.Int64("t", 5, "MAX_SLEEP_TIME") // flag -t
  76         MAX_PRODUCTIONS = flag.Int("m", 0, "MAX_PRODUCTIONS, 0 for infinity") // flag -m
  77         N_PRODUCERS = flag.Int("p", 3, "N_PRODUCERS") // flag -p
  78         N_CONSUMERS = flag.Int("c", 3, "N_CONSUMERS") // flag -c
  79         pipe = make(chan int, *BUFFER_SIZE)
  80         quit    = make(chan int)
  81 )
  82
  83 func producer (id int) {
  84         for i := 0; i < *MAX_PRODUCTIONS || *MAX_PRODUCTIONS == 0; i++ {
  85                 Println(id, "producing:", i + id * 1e5)
  86                 send(pipe, i + id * 1e5)
  87                 random_sleep()
  88         }
  89         signal(quit)
  90 }
  91
  92 func consumer (id int) {
  93         for {
  94                 v := recv(pipe)
  95                 if closed(pipe) { // canal fechado?
  96                         break
  97                 }
  98                 Println("\t\t\t", id, "consuming:", v)
  99                 random_sleep()
 100         }
 101         signal(quit)
 102 }
 103
 104 func main () {
 105         flag.Parse() // processa flags
 106         Println("BUFFER_SIZE =", *BUFFER_SIZE)
 107         Println("MAX_SLEEP_TIME =", *MAX_SLEEP_TIME)
 108         Println("MAX_PRODUCTIONS =", *MAX_PRODUCTIONS)
 109         Println("N_PRODUCERS =", *N_PRODUCERS)
 110         Println("N_CONSUMERS =", *N_CONSUMERS)
 111         for i := 0; i < *N_PRODUCERS; i++ { // cria produtores
 112                 go producer(i + 1)
 113         }
 114         for i := 0; i < *N_CONSUMERS; i++ { // cria consumidores
 115                 go consumer(i + 1)
 116         }
 117         for i := 0; i < *N_PRODUCERS; i++ { // espera o término dos produtores
 118                 wait(quit)
 119         }
 120         close(pipe)     // fecha comunicação
 121         for i := 0; i < *N_CONSUMERS; i++ {     // espera o término dos consumidores
 122                 wait(quit)
 123         }
 124 }
 125 </file>