concurrency examples.

Author: anandology

examples/concurrency/crawler.go

@@ -0,0 +1,61 @@
+// concurrent web crawler
+// Adopted from the example from "The Go Programming Language"
+package main
+
+import (
+    "log"
+    "os"
+
+    "gopl.io/ch5/links"
+)
+
+var done = make(chan bool)
+//var rateLimiter = make(chan int, 4)
+
+// visits given URL and returns all the links present in that page
+func crawl(url string) []string {
+    //rateLimiter <- 0
+    log.Println(url)
+
+    links, err := links.Extract(url)
+
+    //<-rateLimiter
+
+    if err != nil {
+        log.Print(err) // print error and ignore
+    }
+    return links
+}
+
+func startCrawler(worklist chan string) {
+    visited := make(map[string]bool)
+
+    for link := range worklist {
+        if visited[link] {
+            continue // skip already visited pages
+        }
+        visited[link] = true // mark as visited
+
+        // passing link as argument is very important here.
+        // If we don't do that then the function will pick the value of link
+        // at the time of running, not at the time of starting this
+        // function. Since the loop variable `link` is changing in every
+        // iteration, it is important to pass a copy of that to the
+        // goroutine
+        go func(link string) {
+            newLinks := crawl(link)
+            for _, newLink := range newLinks {
+                worklist <- newLink
+            }
+        }(link)
+    }
+}
+
+func main() {
+    worklist := make(chan string)
+    go startCrawler(worklist)
+
+    worklist <- os.Args[1]
+
+    <-done
+}

examples/concurrency/display.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func display(name string, n int) {
+    for i := 0; i < n; i++ {
+        fmt.Printf("%d: %s\n", i, name)
+    }
+}
+
+func main() {
+    go display("A", 10)
+    display("B", 10)
+
+    // hack to wait till the goroutine finished
+    time.Sleep(1 * time.Second)
+}

examples/concurrency/display_v2.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+    "fmt"
+)
+
+func display(name string, n int, done chan bool) {
+    for i := 0; i < n; i++ {
+        fmt.Printf("%d: %s\n", i, name)
+    }
+    done <- true
+}
+
+func main() {
+    done := make(chan bool)
+
+    go display("A", 10, done)
+    go display("B", 10, done)
+    go display("C", 10, done)
+
+    // receive something from the channel. blocks until someone sends it
+    <-done
+    <-done
+    <-done
+}

examples/concurrency/echoserver.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+    "bufio"
+    "fmt"
+    "io"
+    "log"
+    "net"
+)
+
+func handleConn(c net.Conn) {
+    defer c.Close()
+
+    input := bufio.NewScanner(c)
+    for input.Scan() {
+        echo(c, input.Text())
+    }
+}
+
+func echo(c net.Conn, msg string) {
+    _, err := io.WriteString(c, msg+"\n")
+    if err != nil {
+        log.Print("err") // connection failed
+    }
+}
+
+func main() {
+    // start listening on port 8000
+    listener, err := net.Listen("tcp", "localhost:8000")
+    if err != nil {
+        log.Fatal(err)
+    }
+    fmt.Println("started server on localhost:8000")
+
+    for {
+        conn, err := listener.Accept()
+        if err != nil {
+            log.Print("err") // connection failed
+            continue
+        }
+        go handleConn(conn)
+    }
+}

examples/concurrency/helloserver.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+    "fmt"
+    "io"
+    "log"
+    "net"
+    "time"
+)
+
+func handleConn(c net.Conn) error {
+    defer c.Close()
+    _, err := io.WriteString(c, "Hello from Server!\n")
+    if err != nil {
+        return err
+    }
+    time.Sleep(5 * time.Second)
+    _, err = io.WriteString(c, "Bye from Server!\n")
+    if err != nil {
+        return err
+    }
+    return nil
+}
+
+func main() {
+    // start listening on port 8000
+    listener, err := net.Listen("tcp", "localhost:8000")
+    if err != nil {
+        log.Fatal(err)
+    }
+    fmt.Println("started server on localhost:8000")
+
+    for {
+        conn, err := listener.Accept()
+        if err != nil {
+            log.Print("err") // connection failed
+            continue
+        }
+        go handleConn(conn)
+    }
+}

examples/concurrency/netcat.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"io"
+	"log"
+	"net"
+	"os"
+)
+
+func mustCopy(dst io.Writer, src io.Reader) {
+	if _, err := io.Copy(dst, src); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func main() {
+	host := os.Args[1]
+	port := os.Args[2]
+	conn, err := net.Dial("tcp", host+":"+port)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer conn.Close()
+	go mustCopy(os.Stdout, conn)
+	mustCopy(conn, os.Stdin)
+}

examples/concurrency/pipeline.go

@@ -0,0 +1,37 @@
+package main
+
+import "fmt"
+
+func numbers(n int) <-chan int {
+    c := make(chan int)
+    go func() {
+        for i := 0; i < n; i++ {
+            c <- i
+        }
+        close(c)
+    }()
+    return c
+}
+
+func squares(seq <-chan int) <-chan int {
+    c := make(chan int)
+    go func() {
+        for n := range seq {
+            c <- n * n
+        }
+        close(c)
+    }()
+    return c
+}
+
+func printer(seq <-chan int) {
+    for n := range seq {
+        fmt.Println(n)
+    }
+}
+
+func main() {
+    n := numbers(10)
+    sq := squares(n)
+    printer(sq)
+}

examples/concurrency/race.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+    "fmt"
+    "sync"
+)
+
+var sum int
+var lock sync.Mutex
+
+func compute(n int, w *sync.WaitGroup) {
+    for i := 0; i < n; i++ {
+        //lock.Lock()
+        sum++
+        //lock.Unlock()
+    }
+    w.Done()
+}
+
+func main() {
+    var w sync.WaitGroup
+
+    w.Add(3)
+    n := 100000
+    go compute(n, &w)
+    go compute(n, &w)
+    go compute(n, &w)
+    w.Wait()
+    fmt.Println("sum =", sum)
+}