add practice of go:getting started course

.gitignore

@@ -0,0 +1,5 @@
+*
+!*/
+!*.*
+**/*.out
+**/vendor

golang/course/concurrent_programming_with_go/channelsDemo/closeChannel.go

@@ -0,0 +1,42 @@
+package channelsdemo
+
+import (
+	"bytes"
+	"fmt"
+	"runtime/debug"
+	"sync"
+)
+
+func closeChannelsDemo() {
+
+	wg := &sync.WaitGroup{}
+
+	ch := make(chan int, 1)
+
+	wg.Add(2)
+	go func(ch <-chan int, wg *sync.WaitGroup) {
+
+		gr := bytes.Fields(debug.Stack())[1]
+		fmt.Println("id: ", string(gr))
+
+		fmt.Println("message received 1: ", <-ch)
+		// close(ch)
+		if msg, ok := <-ch; ok {
+			fmt.Println(msg, ok)
+		}
+		// fmt.Println(<-ch)
+		// ch <- 5
+		wg.Done()
+	}(ch, wg)
+
+	go func(ch chan<- int, wg *sync.WaitGroup) {
+		ch <- 42
+		fmt.Println("message sent")
+		close(ch)
+		//ch <- 50
+		//fmt.Println(<-ch)
+		wg.Done()
+	}(ch, wg)
+
+	wg.Wait()
+}

golang/course/concurrent_programming_with_go/channelsDemo/forLoop.go

@@ -0,0 +1,35 @@
+package channelsdemo
+
+import (
+	"fmt"
+	"math/rand"
+	"sync"
+)
+
+func forLoop() {
+	wg := &sync.WaitGroup{}
+
+	ch := make(chan int, 1)
+
+	wg.Add(2)
+	go func(ch <-chan int, wg *sync.WaitGroup) {
+
+		i := 1
+		for msg := range ch{			
+			fmt.Println("message received 1: ", msg, i)
+			i++
+		}
+		wg.Done()
+	}(ch, wg)
+
+	go func(ch chan<- int, wg *sync.WaitGroup) {
+		for i := 0; i < 10; i++ {
+			ch <- rand.Intn(100)
+		}
+		fmt.Println("message sent")
+		close(ch)
+		wg.Done()
+	}(ch, wg)
+
+	wg.Wait()
+}

golang/course/concurrent_programming_with_go/channelsDemo/main.go

@@ -0,0 +1,22 @@
+package channelsdemo
+
+import "fmt"
+
+const (
+	maxTest = 10
+)
+
+func Main() {
+
+	// simpleChannelsDemo()
+
+	// typedChannelsDemo()
+
+	// closeChannelsDemo()
+
+	// forLoop()
+
+	syncWithRWMutexAndChannel()
+
+	fmt.Println("\nend of channel's demo")
+}

golang/course/concurrent_programming_with_go/channelsDemo/main1.go

@@ -0,0 +1,68 @@
+package channelsdemo
+
+import (
+	"fmt"
+	"main/shared"
+	"sync"
+	"time"
+)
+
+func queryDatabase(id int) (shared.Book, bool) {
+	time.Sleep(100 * time.Millisecond)
+	for _, b := range shared.Booklist {
+		if b.ID == id {
+			return b, true
+		}
+	}
+
+	return shared.Book{}, false
+}
+
+func syncWithRWMutexAndChannel() {
+	wg := &sync.WaitGroup{}
+	m := &sync.RWMutex{}
+	CacheCh := make(chan shared.Book)
+	dbCh := make(chan shared.Book)
+
+	for i := 0; i < maxTest; i++ {
+		id := shared.Rnd.Intn(8) + 1
+
+		wg.Add(2)
+
+		go func(id int, wg *sync.WaitGroup, m *sync.RWMutex, ch chan<- shared.Book) {
+			if b, ok := shared.QueryCache(id); ok {
+				ch <- b
+			}
+			wg.Done()
+		}(id, wg, m, CacheCh)
+
+		go func(id int, wg *sync.WaitGroup, m *sync.RWMutex, ch chan<- shared.Book) {
+			if b, ok := queryDatabase(id); ok {
+				m.Lock()
+				shared.Cache[id] = b
+				m.Unlock()
+				ch <- b
+			} else{
+				ch <- shared.Book{ID: id}
+			}
+			wg.Done()
+		}(id, wg, m, dbCh)
+
+		go func(cacheCh, db <-chan shared.Book) {
+			select {
+			case b := <-cacheCh:
+				fmt.Println("from cache")
+				fmt.Println(b)
+				<-dbCh
+			case b := <-dbCh:
+				fmt.Println("from database")
+				fmt.Println(b)
+			}
+		}(CacheCh, dbCh)
+
+		time.Sleep(120 * time.Millisecond)
+		//fmt.Printf("Book not found with id : %v\n", id)
+	}
+
+	wg.Wait()
+}

golang/course/concurrent_programming_with_go/channelsDemo/simpleChannelsDemo.go

@@ -0,0 +1,35 @@
+package channelsdemo
+
+import (
+	"fmt"
+	"sync"
+)
+
+func simpleChannelsDemo() {
+	wg := &sync.WaitGroup{}
+
+	ch := make(chan int, 2)
+
+	wg.Add(3)
+	go func(ch chan int, wg *sync.WaitGroup) {
+		fmt.Println("message received 1: ", <-ch)
+		ch <- 0
+		wg.Done()
+	}(ch, wg)
+
+	go func(ch chan int, wg *sync.WaitGroup) {
+		ch <- 42
+		ch <- 50
+		fmt.Println("message sent")
+		fmt.Println("message received", <-ch, <-ch)
+		wg.Done()
+	}(ch, wg)
+
+	go func(ch chan int, wg *sync.WaitGroup) {
+		fmt.Println("message received 2: ", <-ch)
+		ch <- 1
+		wg.Done()
+	}(ch, wg)
+
+	wg.Wait()
+}

golang/course/concurrent_programming_with_go/channelsDemo/typedChannelsDemo.go

@@ -0,0 +1,27 @@
+package channelsdemo
+
+import (
+	"fmt"
+	"sync"
+)
+
+func typedChannelsDemo() {
+
+	wg := &sync.WaitGroup{}
+
+	ch := make(chan int, 1)
+
+	wg.Add(2)
+	go func(ch <-chan int, wg *sync.WaitGroup) {
+		fmt.Println("message received 1: ", <-ch)
+		wg.Done()
+	}(ch, wg)
+
+	go func(ch chan<- int, wg *sync.WaitGroup) {
+		ch <- 42
+		fmt.Println("message sent")
+		wg.Done()
+	}(ch, wg)
+
+	wg.Wait()
+}

golang/course/concurrent_programming_with_go/concurrencyLess/main.go

@@ -0,0 +1,30 @@
+package concurrencyless
+
+import (
+	"fmt"
+	"main/shared"
+	"time"
+)
+
+func Main() {
+	for i := 0; i < 10; i++ {
+		id := shared.Rnd.Intn(shared.LenOfBooks()) + 1
+
+		if b, ok := shared.QueryCache(id); ok {
+			fmt.Println("from cache")
+			fmt.Println(b)
+			continue
+		}
+
+		if b, ok := shared.QueryDatabase(id); ok {
+			fmt.Println("from  database")
+			fmt.Println(b)
+			continue
+		}
+
+		fmt.Printf("Book not found with id : %v", id)
+		time.Sleep(150 * time.Millisecond)
+	}
+
+	fmt.Println("\nend of general secenario")
+}

golang/course/concurrent_programming_with_go/go.mod

@@ -0,0 +1,3 @@
+module main
+
+go 1.19

golang/course/concurrent_programming_with_go/goroutines/main.go

@@ -0,0 +1,37 @@
+package goroutines
+
+import (
+	"fmt"
+	"main/shared"
+	"time"
+)
+
+func Main() {
+
+	for i := 0; i < 20; i++ {
+		id := shared.Rnd.Intn(shared.LenOfBooks()) + 1
+
+		fmt.Printf("\nquery no: %d\n", i+1)
+
+		go func(id int) {
+			if b, ok := shared.QueryCache(id); ok {
+				fmt.Println("from cache")
+				fmt.Println(b)
+			}
+		}(id)
+
+		go func(id int) {
+			if b, ok := shared.QueryDatabase(id); ok {
+				fmt.Println("from  database")
+				fmt.Println(b)
+			}
+		}(id)
+
+		fmt.Printf("Book not found with id : %v\n", id)
+		time.Sleep(150 * time.Millisecond)
+	}
+
+	time.Sleep(1 * time.Second)
+
+	fmt.Println("\nend of goroutines")
+}

golang/course/concurrent_programming_with_go/main.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	channelsdemo "main/channelsDemo"
+)
+
+func main() {
+	fmt.Println("start of concurrent programming with go")
+
+	// fmt.Println( reflect.TypeOf(time.Now()).Kind())
+
+	// concurrencyless.Main()
+
+	// goroutines.Main()
+
+	// syncpackage.Main()
+
+	channelsdemo.Main()
+}

golang/course/concurrent_programming_with_go/shared/books.go

@@ -0,0 +1,63 @@
+package shared
+
+import "fmt"
+
+type Book struct {
+	ID            int
+	Title         string
+	Author        string
+	YearPublished int
+}
+
+func (b Book) String() string {
+	return fmt.Sprintf(""+
+		"ID: %d\n"+
+		"\tTitle: %q\n"+
+		"\tAuthor: %q\n"+
+		"\tPubliched: %v\n", b.ID, b.Title, b.Author, b.YearPublished)
+}
+
+var Booklist = []Book{
+	{
+		ID:            1,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            2,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            3,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            4,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            5,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            7,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+	{
+		ID:            8,
+		Title:         "book<ID>",
+		Author:        "book<Author>",
+		YearPublished: 2000,
+	},
+}