xxxxxxxxxx
package main
import (
"fmt"
)
func main() {
var (
release chan bool = make(chan bool, 1)
received chan string = make(chan string)
)
release <- true
go func(receiveChan chan string) {
<-release
receiveChan <- "Hello World 1"
}(received)
release <- true
go func(receiveChan chan string) {
<-release
data := <-receiveChan
fmt.Println("data 1", data)
receiveChan <- "Hello World 2"
}(received)
release <- true
go func(receiveChan chan string) {
<-release
data := <-receiveChan
fmt.Println("data 2", data)
}(received)
}
xxxxxxxxxx
func main() {
wg := sync.WaitGroup{}
wg.Add(2)
go TestingOne("hello wordl 1", &wg)
go TestingTwo("hello wordl 2", &wg)
wg.Wait()
}
func TestingOne(msg string, wg *sync.WaitGroup) {
fmt.Println(msg)
wg.Done()
}
func TestingTwo(msg string, wg *sync.WaitGroup) {
fmt.Println(msg)
wg.Done()
}
xxxxxxxxxx
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"golang.org/x/sync/errgroup"
)
func main() {
var g errgroup.Group
users := make(map[string]interface{})
todos := make(map[string]interface{})
g.Go(func() error {
res, err := http.Get("https://jsonplaceholder.typicode.com/users/1")
if err != nil {
defer log.Println(err)
return err
}
defer res.Body.Close()
if err := json.NewDecoder(res.Body).Decode(&users); err != nil {
defer log.Println(err)
return err
}
return nil
})
goRes := g.TryGo(func() error {
res, err := http.Get("https://jsonplaceholder.typicode.com/todos/1")
if err != nil {
defer log.Println(err)
return err
}
defer res.Body.Close()
if err := json.NewDecoder(res.Body).Decode(&todos); err != nil {
defer log.Println(err)
return err
}
return nil
})
if !goRes {
fmt.Println("Gorutine active not found", goRes)
}
if err := g.Wait(); err != nil {
defer log.Println(err)
panic(err)
}
fmt.Printf("Fetch data success users %s \n", users["name"])
fmt.Printf("Fetch data success todos %s \n", todos["title"])
}
xxxxxxxxxx
package main
import (
"fmt"
"sync"
)
type Login struct {
Email string `validate:"required" json:"email"`
Password string `validate:"required" json:"password"`
}
func main() {
var (
totalStruct int = 1000000000000
countStruct int
wg *sync.WaitGroup = new(sync.WaitGroup)
payloads []Login = []Login{}
payloadsChan chan []Login = make(chan []Login, totalStruct)
release chan bool = make(chan bool, totalStruct)
)
for i := 0; i < totalStruct; i++ {
wg.Add(1)
go func() {
wg.Done()
payloads := []Login{}
payloads = append(payloads, Login{Email: "johndoe@#gmail.com", Password: "qwerty12"})
countStruct++
if countStruct == totalStruct {
release <- true
}
payloadsChan <- payloads
}()
payloads = append(payloads, <-payloadsChan )
}
wg.Wait()
fmt.Println(len(payloads))
}
xxxxxxxxxx
func PoolNew() {
var (
loopCount = 10000000 // 10000000 (10JT) - 100000000 (100JT) - 1000000000 (1M) - 100000000000 (1T)
maxOfGorutines = 1000
wg sync.WaitGroup
mutex sync.Mutex
users []User = []User{}
)
start := time.Now()
fmt.Printf("Start Time: %s\n", time.Since(start))
for i := 0; i < loopCount; i += maxOfGorutines {
wg.Add(1)
go func(startIndex, endIndex int) {
defer wg.Done()
for j := startIndex; j < endIndex; j++ {
res, err := http.Get("https://jsonplaceholder.typicode.com/users")
if err != nil {
log.Fatal(err)
}
defer res.Body.Close()
resByte, err := io.ReadAll(res.Body)
if err != nil {
log.Fatal(err)
}
mutex.Lock()
if err := json.Unmarshal(resByte, &users); err != nil {
log.Fatal(err)
}
mutex.Unlock()
}
}(i, i+maxOfGorutines)
}
wg.Wait()
fmt.Printf("Total User: %d\n", len(users))
fmt.Printf("Finish Time: %s\n", time.Since(start))
xxxxxxxxxx
func PoolNew() {
var (
loopCount = 10000000 // 10000000 (10JT) - 100000000 (100JT) - 1000000000 (1M) - 100000000000 (1T)
maxOfGorutines = 1000
wg sync.WaitGroup
users []User
mutex sync.Mutex
)
start := time.Now()
for i := 0; i < loopCount; i += maxOfGorutines {
wg.Add(1)
go func(startIndex, endIndex int) {
defer wg.Done()
for j := startIndex; j < endIndex; j++ {
user := User{
Name: "Jamal Cavalera",
Age: 23,
DateOfBirth: "17 Agustus 2000",
PlaceOfBirth: "Jakarta",
}
mutex.Lock()
users = append(users, user)
mutex.Unlock()
}
}(i, i+maxOfGorutines)
}
wg.Wait()
}
xxxxxxxxxx
package main
import (
"fmt"
)
func main() {
var (
release chan bool = make(chan bool, 1)
received chan string = make(chan string)
)
release <- true
go func(receiveChan chan string) {
<-release
receiveChan <- "Hello World 1"
}(received)
release <- true
go func(receiveChan chan string) {
<-release
data := <-receiveChan
fmt.Println("data 1", data)
receiveChan <- "Hello World 2"
}(received)
release <- true
go func(receiveChan chan string) {
<-release
data := <-receiveChan
fmt.Println("data 2", data)
}(received)
}