pc_sem.go~

   1 /* pc_sem.go */
   2
   3 package main
   4
   5 import (
   6         . "fmt"
   7         "crypto/rand"
   8         "time"
   9 )
  10
  11 func random_between (begin, end int64) int64 {
  12         random_byte := make([]byte, 1)
  13         rand.Read(random_byte)
  14         return int64(random_byte[0]) % (end - begin + 1) + begin
  15 }
  16
  17 func random_sleep () {
  18         time.Sleep(random_between(0, MAX_SLEEP_TIME) * 10e7)
  19 }
  20
  21 func signal (channel chan int) {
  22         if len(channel) < cap(channel) || cap(channel) == 0 {
  23                 channel <- 0
  24         }
  25 }
  26
  27 func wait (channel chan int) {
  28         <-channel
  29 }
  30
  31 const (
  32         MAX_SLEEP_TIME = 5
  33         BUFFER_SIZE = 5
  34 )
  35
  36 var (
  37         mutex = make(chan int, 1);
  38         empty chan int;
  39         full    chan int;
  40         buffer []int;
  41         front = 0;
  42         rear    = 0
  43 )
  44
  45 func producer () {
  46         for i := 0; ; i++ { // laço infinito
  47                 wait(empty)
  48                 wait(mutex)
  49                         Println("producing:", i)
  50                         buffer[rear] = i
  51                         rear = (rear + 1) % BUFFER_SIZE
  52                 signal(mutex)
  53                 signal(full)
  54                 random_sleep()
  55         }
  56 }
  57
  58 func consumer () {
  59         for { // laço infinito
  60                 wait(full)
  61                 wait(mutex)
  62                         v := buffer[front]
  63                         front = (front + 1) % BUFFER_SIZE
  64                         Println("\t\t\tconsuming:", v)
  65                 signal(mutex)
  66                 signal(empty)
  67                 random_sleep()
  68         }
  69 }
  70
  71 func main () {
  72         buffer = make([]int, BUFFER_SIZE)
  73         empty = make(chan int, BUFFER_SIZE);
  74         full = make(chan int, BUFFER_SIZE)
  75         for i := 0; i < BUFFER_SIZE; i++ { // inicializa empty com o valor BUFFER\_SIZE
  76                 signal(empty)
  77         }
  78         signal(mutex)   // inicializa mutex com o valor 1
  79         go producer()
  80         go consumer()
  81         wait(make(chan int)) // espera indefinidamente
  82 }
  83