Go Concurrency – Inchkeith Consulting Ltd

Basic Concurrency. Creates 3 go routines which loop 10 times and prinT a message

package main
import (
	"fmt"
	"time"
)
func loop(num int, duration int) {
	for i := 0; i < duration; i++ {
		fmt.Println(num, i)
		time.Sleep(500 * time.Millisecond)
	}
}
func main() {
	go loop(1, 10)
	go loop(2, 10)
	go loop(3, 10)
	var input string
	fmt.Scanln(&input)
}

package main

import (

"fmt"

"time"

)

func loop(num int, duration int) {

for i := 0; i < duration; i++ {

fmt.Println(num, i)

time.Sleep(500 * time.Millisecond)

}

func main() {

go loop(1, 10)

go loop(2, 10)

go loop(3, 10)

var input string

fmt.Scanln(&input)

}

Concurrency with Channels. Creates 2 channels which each send a message back to the primary thread

package main
import (
	"fmt"
	"time"
)
func channel(num int, channel chan string, duration int) {
	for {
		message := fmt.Sprintf("from: %d", num)
		channel <- message
		time.Sleep(500 * time.Millisecond)
	}
}
func main() {
	c1 := make(chan string)
	c2 := make(chan string)
	go channel(1, c1, 100)
	go channel(2, c2, 100)
	for {
		select {
		case msg1 := <-c1:
			fmt.Println(msg1)
		case msg2 := <-c2:
			fmt.Println(msg2)
		}
	}
	var input string
	fmt.Scanln(&input)
}

package main

import (

"fmt"

"time"

)

func channel(num int, channel chan string, duration int) {

for {

message := fmt.Sprintf("from: %d", num)

channel <- message

time.Sleep(500 * time.Millisecond)

}

func main() {

c1 := make(chan string)

c2 := make(chan string)

go channel(1, c1, 100)

go channel(2, c2, 100)

for {

select {

case msg1 := <-c1:

fmt.Println(msg1)

case msg2 := <-c2:

fmt.Println(msg2)

}

var input string

fmt.Scanln(&input)

}

Asynchronous Channels. This example creates 2 channels for 2 separate go routines which then pass messages back and forth

package main
import (
	"fmt"
	"time"
)
func channel(num int, channel chan string, duration int) {
	var count int = 0
	for {
		message := fmt.Sprintf("from: %d - %d", num, count)
		fmt.Println("Sending", message)
		channel <- message
		time.Sleep(500 * time.Millisecond)
		fmt.Printf("%d - Waiting...\n", num)
		msg2 := <-channel
		fmt.Println(msg2)
		count++
	}
}
func main() {
	c1 := make(chan string, 1)
	c2 := make(chan string, 1)
	go channel(1, c1, 100)
	go channel(2, c2, 100)
	var input string
	fmt.Scanln(&input)
}

package main

import (

"fmt"

"time"

)

func channel(num int, channel chan string, duration int) {

var count int = 0

for {

message := fmt.Sprintf("from: %d - %d", num, count)

fmt.Println("Sending", message)

channel <- message

time.Sleep(500 * time.Millisecond)

fmt.Printf("%d - Waiting...\n", num)

msg2 := <-channel

fmt.Println(msg2)

count++

}

func main() {

c1 := make(chan string, 1)

c2 := make(chan string, 1)

go channel(1, c1, 100)

go channel(2, c2, 100)

var input string

fmt.Scanln(&input)

}

Asynchronous Channels. Finally we create a single channel and then allow 2 go routines to use the same channel to pass messages back and forth, waiting for each channel to receive the message then sending one back

package main
import (
	"fmt"
	"time"
)
func channel(num int, channel chan string, duration int) {
	var count int = 0
	for {
		message := fmt.Sprintf("from: %d - %d", num, count)
		fmt.Println("Sending", message)
		channel <- message
		time.Sleep(500 * time.Millisecond)
		fmt.Printf("%d - Waiting...\n", num)
		msg2 := <-channel
		fmt.Println(msg2)
		count++
	}
}
func main() {
	c1 := make(chan string, 1)
	go channel(1, c1, 100)
	go channel(2, c1, 100)
	var input string
	fmt.Scanln(&input)
}

package main

import (

"fmt"

"time"

)

func channel(num int, channel chan string, duration int) {

var count int = 0

for {

message := fmt.Sprintf("from: %d - %d", num, count)

fmt.Println("Sending", message)

channel <- message

time.Sleep(500 * time.Millisecond)

fmt.Printf("%d - Waiting...\n", num)

msg2 := <-channel

fmt.Println(msg2)

count++

}

func main() {

c1 := make(chan string, 1)

go channel(1, c1, 100)

go channel(2, c1, 100)

var input string

fmt.Scanln(&input)

}