# Parallellik (Concurrency) ## Nima uchun bu muhim? Oldingi darsda yozgan port skanerda portlar birma-bir tekshiriladi — birinchisi tugamasa, ikkinchisi boshlanmaydi. 65 535 portni shu tartibda tekshirish soatlab vaqt oladi. Go'da esa barcha portlarni bir vaqtda tekshirish — atigi bir necha qator kod bilan. Bu **goroutine**lar tufayli mumkin. Pentest uchun bu amaliy hisob: - Python'da 65 535 portni skanerlash: ~18 soat - Go'da goroutine bilan: ~2-3 daqiqa - **Farq: 300-400 marta** ## Concurrency va parallelism — farqi nima? Bu ikki so'z ko'pincha aralashtiriladi, lekin ular turli narsalarni anglatadi. **Concurrency** — bir vaqtning o'zida ko'plab vazifalarni *boshqarish*. Bitta protsessorda ham ishlaydi. Go'ning goroutine'lari — concurrency. **Parallelism** — bir vaqtning o'zida ko'plab vazifalarni *haqiqatan bajarish*. Buning uchun bir nechta CPU core kerak. Rob Pike (Go yaratuvchisi) buni qisqacha aytgan: "Concurrency — ko'p ishni bir vaqtda boshqarish. Parallelism — ko'p ishni bir vaqtda bajarish." Go'da goroutine'lar concurrency'ni ta'minlaydi. Agar kompyuterda bir nechta core bo'lsa, Go ularni avtomatik ishlatib parallelizmga ham erishadi. ## Goroutine — Go'ning yengil "ipi" **Goroutine** — Go runtime boshqaradigan yengil vazifa ipi. Oddiy OS thread ~1 MB xotira oladi. Goroutine esa atigi **~2 KB dan** boshlanadi. | Xususiyat | OS thread (Java, C++) | Go goroutine | |---|---|---| | Xotira | ~1 MB | ~2 KB | | Yaratish vaqti | ~1000 ns | ~10 ns | | 1 GB'da maksimal son | ~1000 | ~500 000 | | Boshqaruvchi | OS kernel | Go runtime | Bu raqamlar amalda nima anglatadi: Go'da **bitta dasturda millionlab vazifani** bir vaqtda boshqarish mumkin — va bu oddiy server uchun ham ishlaydi. Goroutine yaratish juda oddiy — `go` kalit so'zi funksiyadan oldin yoziladi: ```go // Oddiy funksiya chaqiruvi — bloklovchi, tugamaguncha kutiladi sayHello() // Goroutine — bloklamasdan, parallel bajariladi // main funksiya kutmasdan davom etaveradi go sayHello() ``` Oddiy misol: ```go package main import ( "fmt" "time" ) func sayHello(from string) { fmt.Printf("Salom, %s dan!\n", from) } func main() { // Goroutine'lar ishga tushirish go sayHello("goroutine 1") go sayHello("goroutine 2") go sayHello("goroutine 3") // main funksiya goroutine'larni kutmaydi // Bu sleep bo'lmasa, goroutine'lar chiqib ketishi mumkin time.Sleep(100 * time.Millisecond) fmt.Println("Barchasi tugadi") } // Natija (tartib har safar o'zgarishi mumkin): // Salom, goroutine 2 dan! // Salom, goroutine 1 dan! // Salom, goroutine 3 dan! // Barchasi tugadi ``` > [!WARNING] > `main()` funksiya tugasa, barcha goroutine'lar ham to'xtaydi. Goroutine'larni kutmasdan dastur chiqsa — ularning ishi yo'qoladi. `time.Sleep` yomon yechim — keyinroq `WaitGroup` bilan to'g'ri yechimni ko'ramiz. ## sync.WaitGroup — goroutine'larni kutish `time.Sleep` yomon yondashuv — biz goroutine'lar qachon tugashini bilmaymiz. `WaitGroup` esa aniq kutadi. **WaitGroup** — hisoblagich: - `Add(n)` — n ta ish boshlanayotganini bildiradi - `Done()` — bitta ish tugadi - `Wait()` — hisoblagich nolga tushguncha kutadi ```go package main import ( "fmt" "net" "sync" "time" ) func main() { var wg sync.WaitGroup // hisoblagich — zero value, darhol ishlatish mumkin target := "scanme.nmap.org" for port := 1; port <= 1000; port++ { wg.Add(1) // goroutine boshlanishidan OLDIN — muhim qoida! go func(p int) { defer wg.Done() // qanday tugashidan qat'iy nazar (xato bilan ham) addr := fmt.Sprintf("%s:%d", target, p) conn, err := net.DialTimeout("tcp", addr, 500*time.Millisecond) if err == nil { fmt.Printf("Port %d ochiq\n", p) conn.Close() } }(port) // port qiymatini goroutine'ga uzatish — muhim! } wg.Wait() // barcha goroutine'lar tugashini kutadi fmt.Println("Skaner tugadi") } ``` `go func(p int) { ... }(port)` da `(port)` ni izoh: `port` o'zgaruvchisi loop ichida o'zgarib turadi. Agar `port` ni to'g'ridan-to'g'ri capture qilsak, barcha goroutine'lar oxirgi `port` qiymatini ko'rishi mumkin. Qiymatni parametr sifatida uzatganda, har goroutine o'z qiymatini oladi. ```mermaid sequenceDiagram participant M as main participant WG as WaitGroup participant G1 as goroutine 1 participant G2 as goroutine 2 M->>WG: Add(2) M->>G1: go scanPort(1) M->>G2: go scanPort(2) M->>WG: Wait() — kutadi G1->>G1: TCP urinish G1->>WG: Done() G2->>G2: TCP urinish G2->>WG: Done() WG-->>M: Ikkisi tugadi, davom et ``` > [!TIP] > `Add(1)` ni goroutine boshlanishidan **oldin** chaqiring. `Done()` ni har doim `defer` bilan — goroutine panic qilsa ham hisoblagich kamayadi. ## Channel — goroutine'lar orasida ma'lumot Goroutine'lar natijalarni bir-biriga qanday uzatadi? **Channel** orqali — bu goroutine'lar orasidagi navbat (queue). Channel yaratish: ```go ch := make(chan int) // unbuffered — qabul qiluvchi bo'lmaguncha bloklanadi ch := make(chan int, 100) // buffered — 100 ta element sig'adi, keyin bloklanadi ``` Yuborish va qabul qilish: ```go ch <- 42 // channel'ga yuborish (blocking — qabul qiluvchi bo'lmaguncha kutadi) value := <-ch // channel'dan qabul qilish (blocking — yuboruvchi bo'lmaguncha kutadi) ``` Oddiy misol — goroutine natijani channel orqali qaytaradi: ```go package main import "fmt" // worker — ish bajaradi va natijani channel'ga yuboradi func worker(num int, results chan<- int) { // chan<- — faqat yozish (receive qilolmaydi) result := num * num // kvadrat results <- result } func main() { results := make(chan int, 3) // 3 ta uchun buferlangan go worker(2, results) // 4 go worker(3, results) // 9 go worker(4, results) // 16 // Uchta natijani o'qish for i := 0; i < 3; i++ { val := <-results fmt.Println(val) } } // Natija (tartib o'zgarishi mumkin): // 9 // 4 // 16 ``` `chan<-` va `<-chan` — channel yo'nalishlari: ```go func sender(ch chan<- int) { ch <- 10 // faqat yuborish // <-ch // ERROR: receive mumkin emas } func receiver(ch <-chan int) { val := <-ch // faqat qabul qilish // ch <- 5 // ERROR: send mumkin emas } ``` Bu xatolarning oldini oladi — funksiya nima qilishi ko'rinadigan bo'ladi. **Unbuffered vs Buffered:** ```go // Unbuffered — sender va receiver bir vaqtda tayyor bo'lishi kerak unbuffered := make(chan int) go func() { unbuffered <- 42 }() // goroutine'da yuborish val := <-unbuffered // asosiy goroutine qabul qiladi — ishlaydi // Buffered — buffer to'lmagunicha bloklanmaydi buffered := make(chan int, 3) buffered <- 1 // OK buffered <- 2 // OK buffered <- 3 // OK buffered <- 4 // BLOCKING! buffer to'ldi ``` Channel yopish — for range bilan ishlash uchun: ```go ch := make(chan int, 3) ch <- 1 ch <- 2 ch <- 3 close(ch) // "Ma'lumot tugadi" signali for val := range ch { fmt.Println(val) // 1, 2, 3 } // close bo'lgandan keyin range tugaydi ``` > [!WARNING] > Yopiq channel'ga yuborish panic beradi. Qabul qilish esa ishlaydi — buferdagi qiymatlarni oladi, keyin zero value qaytaradi. ## sync.Mutex — umumiy ma'lumotni himoya qilish Bir nechta goroutine bir vaqtda bir o'zgaruvchiga yozsa — **race condition** (noto'g'ri natija). 1000 goroutine `counter++` qilsa, natija 1000 bo'lmasligi mumkin. Muammo qanday paydo bo'ladi: ```go var counter int // global o'zgaruvchi func increment(wg *sync.WaitGroup) { defer wg.Done() counter++ // MUAMMO: bu bir atomik amal emas! // Go mashinasi kodi: read → add 1 → write // Ikki goroutine bir vaqtda read qilsa — ikkisi ham eski qiymatni o'qiydi // Ikkisi ham +1 qo'shadi — lekin counter faqat 1 ga oshadi } ``` Race condition borligini tekshirish: ```bash go run -race main.go # WARNING: DATA RACE — agar muammo bo'lsa, bildiradi ``` **Mutex** (Mutual Exclusion) — bir vaqtda faqat bitta goroutine kirishi: ```go package main import ( "fmt" "sync" ) var ( counter int mu sync.Mutex ) func increment(wg *sync.WaitGroup) { defer wg.Done() mu.Lock() // faqat bitta goroutine kiradi — qolganlar kutadi counter++ // critical section — faqat bitta goroutine shu yerda mu.Unlock() // boshqalar uchun qo'yib beriladi } func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go increment(&wg) } wg.Wait() fmt.Println("Counter:", counter) // har doim 1000 } ``` `defer mu.Unlock()` yozish odati bor — lock qilingan joyda unlock yozilsa, unutmaslik kafolati: ```go mu.Lock() defer mu.Unlock() // qanday chiqsa ham, unlock bo'ladi // ... critical code ... ``` **RWMutex** — ko'p o'qish, kam yozish uchun: ```go var ( data = make(map[string]int) rwMutex sync.RWMutex ) // Ko'p goroutine bir vaqtda o'qiy oladi func readData(key string) int { rwMutex.RLock() // Read lock — boshqalar ham o'qiy oladi defer rwMutex.RUnlock() return data[key] } // Faqat bitta goroutine yoza oladi func writeData(key string, value int) { rwMutex.Lock() // Write lock — hech kim o'qiy ham yoza ham olmaydi defer rwMutex.Unlock() data[key] = value } ``` Port skanerda natijalarni `map`da saqlasangiz — yozishda mutex kerak, o'qishda esa `RLock` yetarli. ## select — bir vaqtda bir nechta channel `select` — `switch`ning channel versiyasi. Qaysi channel'dan birinchi ma'lumot kelsa, o'sha `case` bajariladi. ```go func main() { ch1 := make(chan string) ch2 := make(chan string) go func() { time.Sleep(1 * time.Second) ch1 <- "ch1 dan javob" }() go func() { time.Sleep(2 * time.Second) ch2 <- "ch2 dan javob" }() // Birinchi kelganini qabul qilish select { case msg := <-ch1: fmt.Println(msg) // 1 sekunddan keyin bu bajariladi case msg := <-ch2: fmt.Println(msg) } } ``` **Timeout pattern** — eng ko'p ishlatiladigan `select` qo'llash: ```go select { case msg := <-ch: fmt.Println("Javob:", msg) case <-time.After(2 * time.Second): fmt.Println("Timeout — javob kelmadi") } // time.After(d) — d vaqtdan keyin yopiluvchi channel ``` Pentest kodida timeout juda muhim: agar server 2 sekundan ko'p vaqt olsa — keyingi targetga o'tish kerak. Timeout bo'lmasa, dastur "tiqilib" qolishi mumkin. **Non-blocking tekshirish** — `default`: ```go select { case val := <-results: process(val) default: // Hozir channel bo'sh — bloklanmaydi, davom etadi fmt.Println("Hozir natija yo'q") } ``` ## Worker pool pattern 65 535 goroutine yaratish yaxshi emas — xotirani isrof qiladi, OS scheduler'ni yuklamaydi, ba'zan OS limit'ga yetishi mumkin. **Worker pool** esa cheklangan goroutine'lar bilan ishlaydi: vazifalar navbatda turadi, bo'sh worker olib bajaradi. ```mermaid flowchart LR P[port 1..65535] --> CH[ports channel] CH --> W1[worker 1] CH --> W2[worker 2] CH --> W3[worker 3] W1 --> R[results channel] W2 --> R W3 --> R R --> OUT[Ochiq portlar] ``` 100 ta worker bilan port skaner: ```go package main import ( "fmt" "net" "sync" "time" ) // worker — ports channel'dan port oladi, ochiq portni results'ga yuboradi func worker(target string, ports <-chan int, results chan<- int, wg *sync.WaitGroup) { defer wg.Done() for port := range ports { // Har kelgan port uchun TCP ulanishga urinish addr := fmt.Sprintf("%s:%d", target, port) conn, err := net.DialTimeout("tcp", addr, 500*time.Millisecond) if err == nil { conn.Close() results <- port // Ochiq port — natijaga yuborish } // Yopiq port — hech narsa qilmaymiz, keyingisiga o'tamiz } } func main() { target := "scanme.nmap.org" numWorkers := 100 // 65535 emas — 100 ta worker yetarli // Buferlangan channel'lar — worker'lar bloklanmasin ports := make(chan int, numWorkers) results := make(chan int, numWorkers) var wg sync.WaitGroup // 100 ta worker ishga tushirish for i := 0; i < numWorkers; i++ { wg.Add(1) go worker(target, ports, results, &wg) } // Portlarni channel'ga yuborish — alohida goroutine'da // (asosiy goroutine bloklanmasin) go func() { for port := 1; port <= 65535; port++ { ports <- port // worker bo'shguncha kutishi mumkin } close(ports) // "Portlar tugadi" signali — worker'lar tuxtaydi }() // Barcha worker tugagandan so'ng results'ni yopish go func() { wg.Wait() close(results) // Natija yig'ish tugadi }() // Natijalarni yig'ish — results yopilgunicha var openPorts []int for port := range results { openPorts = append(openPorts, port) fmt.Printf("Port %d — ochiq\n", port) } fmt.Printf("\nJami %d ta ochiq port\n", len(openPorts)) } ``` Bu skaner 100 worker bilan ishlaydi — na juda ko'p, na juda kam. Xotira ham, OS ham chidaydi. 65 535 portni ~30-60 sekundda tekshiradi. Nima uchun aynan 100 worker? Empirik qiymat: - **10 ta** — sekin, portlar navbatda kutadi - **100 ta** — optimal: OS file descriptor limit'iga yetmaslik, tarmoq bandwidth'ni to'liq ishlatish - **1000 ta** — OS limit muammolari, xotira sarfi yuqori - **65535 ta** — dastur crash bo'lishi mumkin ## Concurrency qaror daraxti ```mermaid flowchart TD A[Parallel vazifa kerak?] --> B{Nechta vazifa?} B -->|Bitta| C[go func — oddiy goroutine] B -->|Ko'p| D{Natija qaytarish?} D -->|Ha| E[Channel ishlatish] D -->|Yo'q| F[WaitGroup yetarli] E --> G{Bir nechta source?} G -->|Ha| H[select + timeout] G -->|Yo'q| I[Simple receive] F --> J{Umumiy ma'lumot?} J -->|Ha| K[Mutex kerak] J -->|Yo'q| L[Tayyor] ``` ## Qisqacha — eslab qoling 1. **Goroutine** — `go func()`. OS thread'dan 500 marta kam xotira, millionlab ishga tushirish mumkin. 2. **WaitGroup** — goroutine'lar tugashini kutish. `Add(1)` goroutine oldida, `Done()` defer bilan, `Wait()` oxirida. 3. **Channel** — goroutine'lar orasida ma'lumot. `make(chan T)` unbuffered, `make(chan T, n)` buffered. 4. **Mutex** — umumiy ma'lumotni himoya qilish. `go run -race` bilan muammolarni toping. 5. **select** — bir nechta channel'dan birinchi kelganini qabul qilish. Timeout uchun `time.After`. 6. **Worker pool** — cheklangan goroutine'lar bilan ko'p ish bajarish. 65K goroutine emas, 100 ta worker. 7. **Loop ichida goroutine** — port qiymatini parametr sifatida uzating: `go func(p int){ }(port)`. ## Keyingi qadam Keyingi darsda xatolarni professional darajada boshqarishni ko'ramiz: Go'ning `error` interface'i, `errors.Is`, `errors.As`, va custom error tur yaratish.

Parallellik (Concurrency): Go'ning Superpower'i