├── что выведет ├── threads │ ├── 1 │ ├── 2 │ ├── 1.go │ └── 2.go ├── defer │ ├── 1 │ ├── 2 │ ├── 3 │ ├── 4 │ ├── 1.go │ ├── 2.go │ ├── 4.go │ └── 3.go ├── slice │ ├── 1 │ ├── 2 │ ├── 3 │ ├── 4 │ ├── 5 │ ├── 6 │ ├── 7 │ ├── 8 │ ├── 9 │ ├── 10 │ ├── 11 │ ├── 12 │ ├── 13 │ ├── 14 │ ├── 15 │ ├── 16 │ ├── 17 │ ├── 18 │ ├── 19 │ ├── 20 │ ├── 21 │ ├── 22 │ ├── 23 │ ├── 24 │ ├── 25 │ ├── 26 │ ├── 27 │ ├── 28 │ ├── 19.go │ ├── 28.go │ ├── 12.go │ ├── 13.go │ ├── 5.go │ ├── 6.go │ ├── 7.go │ ├── 10.go │ ├── 11.go │ ├── 8.go │ ├── 9.go │ ├── 15.go │ ├── 26.go │ ├── 27.go │ ├── 22.go │ ├── 23.go │ ├── 4.go │ ├── 3.go │ ├── 20.go │ ├── 21.go │ ├── 16.go │ ├── 24.go │ ├── 17.go │ ├── 18.go │ ├── 25.go │ ├── 1.go │ ├── 14.go │ └── 2.go ├── ссылочные типы │ ├── 1 │ ├── 2.go │ └── 1.go ├── область видимости │ ├── 1 │ ├── 2 │ ├── 3 │ ├── 4 │ ├── 5 │ ├── 6 │ ├── 7 │ ├── 8 │ ├── 9 │ ├── 10 │ ├── 10.go │ ├── 9.go │ ├── 8.go │ ├── 4.go │ ├── 6.go │ ├── 7.go │ ├── 5.go │ ├── 1.go │ ├── 2.go │ └── 3.go └── interface │ ├── 1 │ └── 1.go ├── .gitignore ├── основное ├── типы данных ├── константы + iota ├── области видимости ├── array+slice ├── строки ├── int ├── замыкание ├── процесс vs поток ├── defer, panic, recover ├── ооп ├── интерфейсы └── map ├── .idea ├── vcs.xml ├── .gitignore ├── modules.xml └── Golang-interview.iml ├── Список тех вопросов jun+ ├── algorythms ├── ozon_3.go ├── factorial.go ├── Алгоритмы ├── string_reverse.go ├── ozon_2.go ├── select_sort.go ├── interface.go ├── binary_search.go ├── Merge Two Sorted Lists.go ├── quick_sort.go ├── reverse_linked_list.go ├── remove_nth_node.go ├── Valid_Parentheses.go ├── linked_list.go └── cycle_linked_list.go ├── базы данных ├── sql запросы ├── CAP теорема ├── kafka ├── индексы ├── транзакции └── БД ├── сети ├── модель tcp ├── RESTapi ├── rest vs grpc ├── http vs http2 └── модель osi ├── паттерны └── SOLID ├── устройство go └── основное ├── Список технических вопросов ├── конкурентность в go ├── каналы ├── Примитивы синхронизации ├── Термины многопоточности Go └── конкурентность в go ├── Список HR вопросов └── Список тех вопросов updated /что выведет/threads/2: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /что выведет/defer/1: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /что выведет/slice/15: -------------------------------------------------------------------------------- 1 | [1] 2 | -------------------------------------------------------------------------------- /что выведет/slice/19: -------------------------------------------------------------------------------- 1 | [] 2 | -------------------------------------------------------------------------------- /что выведет/slice/22: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /что выведет/slice/28: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /что выведет/slice/5: -------------------------------------------------------------------------------- 1 | [1] 2 | -------------------------------------------------------------------------------- /что выведет/slice/8: -------------------------------------------------------------------------------- 1 | [2] 2 | -------------------------------------------------------------------------------- /что выведет/defer/2: -------------------------------------------------------------------------------- 1 | 5 5 5 5 5 -------------------------------------------------------------------------------- /что выведет/slice/10: -------------------------------------------------------------------------------- 1 | [1 2] 2 | -------------------------------------------------------------------------------- /что выведет/slice/12: -------------------------------------------------------------------------------- 1 | [2 3] 2 | -------------------------------------------------------------------------------- /что выведет/slice/13: -------------------------------------------------------------------------------- 1 | [1 2 3] 2 | -------------------------------------------------------------------------------- /что выведет/slice/14: -------------------------------------------------------------------------------- 1 | [1 2 3] 2 | -------------------------------------------------------------------------------- /что выведет/slice/17: -------------------------------------------------------------------------------- 1 | true 2 | -------------------------------------------------------------------------------- /что выведет/slice/18: -------------------------------------------------------------------------------- 1 | false 2 | -------------------------------------------------------------------------------- /что выведет/slice/20: -------------------------------------------------------------------------------- 1 | false 2 | -------------------------------------------------------------------------------- /что выведет/slice/24: -------------------------------------------------------------------------------- 1 | false 2 | -------------------------------------------------------------------------------- /что выведет/slice/3: -------------------------------------------------------------------------------- 1 | [4 5] 2 | -------------------------------------------------------------------------------- /что выведет/slice/6: -------------------------------------------------------------------------------- 1 | [1 2 3] 2 | -------------------------------------------------------------------------------- /что выведет/ссылочные типы/2.go: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /algorythms/ozon_1.go 2 | -------------------------------------------------------------------------------- /что выведет/defer/4: -------------------------------------------------------------------------------- 1 | done 2 | 32 3 | -------------------------------------------------------------------------------- /что выведет/slice/26: -------------------------------------------------------------------------------- 1 | map[one:1] 2 | -------------------------------------------------------------------------------- /что выведет/область видимости/7: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /что выведет/область видимости/8: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /что выведет/область видимости/9: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /что выведет/slice/4: -------------------------------------------------------------------------------- 1 | [3 4] [3 4] [1 2] 2 | -------------------------------------------------------------------------------- /что выведет/область видимости/1: -------------------------------------------------------------------------------- 1 | two 2 | -------------------------------------------------------------------------------- /что выведет/область видимости/6: -------------------------------------------------------------------------------- 1 | 1 2 | 5 3 | -------------------------------------------------------------------------------- /что выведет/slice/1: -------------------------------------------------------------------------------- 1 | [5 5 5 5] 2 | [5 5 5 5] 3 | -------------------------------------------------------------------------------- /что выведет/interface/1: -------------------------------------------------------------------------------- 1 | Output: 2 | first: [1 2 5] -------------------------------------------------------------------------------- /что выведет/область видимости/3: -------------------------------------------------------------------------------- 1 | a > 1 2 | a > 2 3 | -------------------------------------------------------------------------------- /что выведет/slice/2: -------------------------------------------------------------------------------- 1 | Output: 2 | [5 5 5 5 5] 3 | [1 2 3 4] -------------------------------------------------------------------------------- /что выведет/slice/27: -------------------------------------------------------------------------------- 1 | panic: assignment to entry in nil map -------------------------------------------------------------------------------- /что выведет/defer/3: -------------------------------------------------------------------------------- 1 | counting 2 | done 3 | 3 4 | 2 5 | 1 6 | -------------------------------------------------------------------------------- /что выведет/slice/23: -------------------------------------------------------------------------------- 1 | ./23.go:6:14: invalid map key type []int -------------------------------------------------------------------------------- /что выведет/область видимости/2: -------------------------------------------------------------------------------- 1 | two 2 | three 3 | default 4 | -------------------------------------------------------------------------------- /что выведет/slice/11: -------------------------------------------------------------------------------- 1 | ./11.go:9:23: final index required in 3-index slice -------------------------------------------------------------------------------- /что выведет/slice/9: -------------------------------------------------------------------------------- 1 | ./9.go:9:21: middle index required in 3-index slice -------------------------------------------------------------------------------- /что выведет/область видимости/5: -------------------------------------------------------------------------------- 1 | ./5.go:14:8: value declared but not used -------------------------------------------------------------------------------- /что выведет/ссылочные типы/1: -------------------------------------------------------------------------------- 1 | ./1.go:14:2: cannot assign to a[0] (value of type byte) -------------------------------------------------------------------------------- /что выведет/slice/7: -------------------------------------------------------------------------------- 1 | panic: runtime error: slice bounds out of range [:4] with capacity 3 -------------------------------------------------------------------------------- /что выведет/slice/16: -------------------------------------------------------------------------------- 1 | ./16.go:8:13: invalid operation: a == nil (mismatched types [2]int and untyped nil) -------------------------------------------------------------------------------- /что выведет/slice/21: -------------------------------------------------------------------------------- 1 | ./21.go:8:8: invalid operation: a == []int{} (slice can only be compared to nil) -------------------------------------------------------------------------------- /что выведет/slice/25: -------------------------------------------------------------------------------- 1 | ./25.go:8:8: invalid operation: m == map[string]int{} (map can only be compared to nil) -------------------------------------------------------------------------------- /что выведет/область видимости/10: -------------------------------------------------------------------------------- 1 | ./10.go:7:1: syntax error: non-declaration statement outside function body -------------------------------------------------------------------------------- /что выведет/область видимости/4: -------------------------------------------------------------------------------- 1 | ./4.go:12:8: value declared but not used 2 | ./4.go:16:17: undefined: value -------------------------------------------------------------------------------- /основное/типы данных: -------------------------------------------------------------------------------- 1 | Базовые : 2 | int, float, bool, complex 3 | Составные : 4 | map, slice, array 5 | Указатели -------------------------------------------------------------------------------- /что выведет/slice/19.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := [0]int{} 7 | 8 | fmt.Println(a) 9 | } -------------------------------------------------------------------------------- /что выведет/slice/28.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var m map[string]int 7 | 8 | fmt.Println(m["one"]) 9 | } -------------------------------------------------------------------------------- /что выведет/slice/12.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[1:]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/13.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[:]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[:1]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/6.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[:3]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/7.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[:4]) 10 | } -------------------------------------------------------------------------------- /что выведет/область видимости/10.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | a := 3 8 | 9 | func main() { 10 | fmt.Println(a) 11 | } -------------------------------------------------------------------------------- /что выведет/область видимости/9.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | var a = 3 8 | 9 | func main() { 10 | fmt.Println(a) 11 | } -------------------------------------------------------------------------------- /что выведет/defer/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | i := 0 9 | defer fmt.Println(i) 10 | i++ 11 | return 12 | } -------------------------------------------------------------------------------- /что выведет/slice/10.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[:2:3]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/11.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[1:2:]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/8.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[1:2:3]) 10 | } -------------------------------------------------------------------------------- /что выведет/slice/9.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{1, 2, 3} 9 | fmt.Println(a[1::3]) 10 | } 11 | -------------------------------------------------------------------------------- /что выведет/slice/15.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | var a []int 9 | a = append(a, 1) 10 | fmt.Println(a) 11 | } -------------------------------------------------------------------------------- /что выведет/slice/26.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | m := map[string]int{} 7 | 8 | m["one"] = 1 9 | 10 | fmt.Println(m) 11 | } -------------------------------------------------------------------------------- /что выведет/slice/27.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var m map[string]int 7 | 8 | m["one"] = 1 9 | 10 | fmt.Println(m) 11 | } -------------------------------------------------------------------------------- /что выведет/область видимости/8.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | var a = 3 8 | 9 | func main() { 10 | a := 4 11 | 12 | fmt.Println(a) 13 | } -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Список тех вопросов jun+: -------------------------------------------------------------------------------- 1 | array vs slice 2 | map 3 | типы ошибок в go 4 | обход map 5 | docker 6 | индексы. типы инедксов 7 | нормализация бд 8 | data provider 9 | race condition 10 | kafka 11 | -------------------------------------------------------------------------------- /что выведет/slice/22.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | m := map[[2]int]int{ 7 | {1, 2}: 3, 8 | } 9 | 10 | fmt.Println(m[[2]int{1, 2}]) 11 | } -------------------------------------------------------------------------------- /что выведет/slice/23.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | m := map[[]int]int{ 7 | {1, 2}: 3, 8 | } 9 | 10 | fmt.Println(m[[]int{1, 2}]) 11 | } -------------------------------------------------------------------------------- /algorythms/ozon_3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | var alphabet = []byte{'x', 'y', 'z'} 4 | 5 | func decode(hash string) string { 6 | 7 | } 8 | 9 | func main() { 10 | password := "xxyyii" 11 | 12 | } 13 | -------------------------------------------------------------------------------- /что выведет/slice/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | x := []int{1, 2} 9 | y := []int{3, 4} 10 | ref := x 11 | x = y 12 | fmt.Println(x, y, ref) 13 | } 14 | -------------------------------------------------------------------------------- /что выведет/defer/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | for i := 0; i < 5; i++ { 9 | defer func(i *int) { 10 | fmt.Printf("%v ", *i) 11 | }(&i) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Editor-based HTTP Client requests 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /что выведет/slice/3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | test1 := []int{1, 2, 3, 4, 5} 9 | test1 = test1[:3] 10 | test2 := test1[3:] 11 | fmt.Println(test2[:2]) 12 | } 13 | -------------------------------------------------------------------------------- /что выведет/ссылочные типы/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | s := "abc" 9 | modify(s) 10 | fmt.Println(s) 11 | } 12 | 13 | func modify(a string) { 14 | a[0] = '3' 15 | } -------------------------------------------------------------------------------- /что выведет/defer/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | nums := 1 << 5 // 32 9 | 10 | defer fmt.Println(nums) 11 | 12 | nums = nums >> 1 //16 13 | 14 | fmt.Println("done") 15 | } -------------------------------------------------------------------------------- /что выведет/defer/3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | fmt.Println("counting") 9 | 10 | for i := 1; i < 4; i++ { 11 | defer fmt.Println(i) 12 | } 13 | 14 | fmt.Println("done") 15 | } -------------------------------------------------------------------------------- /что выведет/slice/20.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := []int{} 7 | 8 | if a == nil { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/21.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := []int{} 7 | 8 | if a == []int{} { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/16.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := [2]int{0, 0} 7 | 8 | if a == nil { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/24.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | m := map[string]int{} 7 | 8 | if m == nil { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/17.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := [2]int{0, 0} 7 | 8 | if a == [2]int{} { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/18.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := [2]int{1, 2} 7 | 8 | if a == [2]int{} { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /что выведет/slice/25.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | m := map[string]int{} 7 | 8 | if m == map[string]int{} { 9 | fmt.Println("true") 10 | } else { 11 | fmt.Println("false") 12 | } 13 | } -------------------------------------------------------------------------------- /algorythms/factorial.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main(){ 6 | a := 5 7 | fmt.Println(factorial(a)) 8 | } 9 | 10 | 11 | func factorial(a int) int{ 12 | if a == 1{ 13 | return 1 14 | } else { 15 | return a * factorial(a - 1) 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /что выведет/slice/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func mod(a []int) { 8 | 9 | for i := range a { 10 | a[i] = 5 11 | } 12 | 13 | fmt.Println(a) 14 | } 15 | 16 | func main() { 17 | sl := []int{1, 2, 3, 4} 18 | mod(sl) 19 | fmt.Println(sl) 20 | } -------------------------------------------------------------------------------- /algorythms/Алгоритмы: -------------------------------------------------------------------------------- 1 | https://leetcode.com/problems/valid-parentheses/ 2 | https://leetcode.com/problems/reverse-linked-list/ 3 | https://leetcode.com/problems/remove-nth-node-from-end-of-list/ 4 | https://leetcode.com/problems/linked-list-cycle/ 5 | https://leetcode.com/problems/merge-two-sorted-lists/ -------------------------------------------------------------------------------- /что выведет/slice/14.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := []int{} 9 | a = append(a, 1) 10 | a = append(a, 2) 11 | a = append(a, 3) 12 | add(a) 13 | fmt.Println(a) 14 | } 15 | 16 | func add(a []int) { 17 | a = append(a, 4) 18 | } -------------------------------------------------------------------------------- /что выведет/область видимости/4.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | m := map[string]int{ 9 | "one": 1, 10 | } 11 | 12 | if value, ok := m["one"]; ok { 13 | fmt.Println("one exists!") 14 | } 15 | 16 | fmt.Println(value) 17 | } -------------------------------------------------------------------------------- /что выведет/slice/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func mod(a []int) { 8 | a = append(a, 125) 9 | 10 | for i := range a { 11 | a[i] = 5 12 | } 13 | 14 | fmt.Println(a) 15 | } 16 | 17 | func main() { 18 | sl := []int{1, 2, 3, 4} 19 | mod(sl) 20 | fmt.Println(sl) 21 | } -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /что выведет/область видимости/6.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | m := map[string]int{ 9 | "one": 1, 10 | } 11 | 12 | value := 5 13 | 14 | if value, ok := m["one"]; ok { 15 | fmt.Println(value) 16 | } 17 | 18 | fmt.Println(value) 19 | } -------------------------------------------------------------------------------- /что выведет/область видимости/7.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | m := map[string]int{ 9 | "zero": 0, 10 | } 11 | 12 | value := 5 13 | 14 | if value, ok := m["one"]; ok { 15 | fmt.Println(value) 16 | } 17 | 18 | fmt.Println(value) 19 | } -------------------------------------------------------------------------------- /algorythms/string_reverse.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main(){ 6 | s := "ABCD" 7 | s1 := "QWERTyuiop" 8 | fmt.Println(reverse(s), reverse(s1)) 9 | } 10 | 11 | func reverse(s string) string{ 12 | var res string 13 | 14 | for _, v := range(s){ 15 | res = string(v) + res 16 | } 17 | return res 18 | } -------------------------------------------------------------------------------- /что выведет/область видимости/5.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | m := map[string]int{ 9 | "one": 1, 10 | } 11 | 12 | value := 5 13 | 14 | if value, ok := m["one"]; ok { 15 | fmt.Println("one exists!") 16 | } 17 | 18 | fmt.Println(value) 19 | } -------------------------------------------------------------------------------- /что выведет/threads/1: -------------------------------------------------------------------------------- 1 | Output : 2 1 3 2 | Объяснение : 3 | 1. поток заходит первую функцию и слипается на 2 секунды. 4 | 2. основной поток заходит во вторую функцию и печатает "2". 5 | 3. основной поток доходит до wg.Wait и ждет пока выполнится первая функция -> печатется "1" 6 | 4. основной поток, дождавшись выполнения первой функции, печатает "3" -------------------------------------------------------------------------------- /.idea/Golang-interview.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /algorythms/ozon_2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func merge(arrs ...[]int) []int { 6 | res := make([]int, 0, len(arrs)) 7 | fmt.Println() 8 | 9 | for _, v := range arrs { 10 | res = append(res, v...) 11 | } 12 | return res 13 | } 14 | 15 | func main() { 16 | fmt.Println(merge([]int{1, 2}, []int{3, 4}, []int{5, 6}, []int{7, 8, 9, 10})) 17 | } 18 | -------------------------------------------------------------------------------- /что выведет/threads/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "sync" 6 | "time" 7 | ) 8 | 9 | func main() { 10 | var wg sync.WaitGroup 11 | 12 | wg.Add(1) 13 | go func() { 14 | time.Sleep(time.Second * 2) 15 | fmt.Println("1") 16 | wg.Done() 17 | }() 18 | 19 | go func() { 20 | fmt.Println("2") 21 | }() 22 | 23 | wg.Wait() 24 | fmt.Println("3") 25 | } -------------------------------------------------------------------------------- /что выведет/область видимости/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := 2 9 | 10 | switch a { 11 | case 1: 12 | fmt.Println("one") 13 | case 2: 14 | fmt.Println("two") 15 | case 3: 16 | fmt.Println("three") 17 | break 18 | default: 19 | fmt.Println("default") 20 | } 21 | } -------------------------------------------------------------------------------- /базы данных/sql запросы: -------------------------------------------------------------------------------- 1 | SELECT *. count() 2 | FROM 3 | WHERE можно добавить IN/ NOT IN. AND/OR 4 | GROUP BY - группировка по столбцу 5 | HAVING - фильтрация на уровне сгруппированных данных 6 | ORDER BY - сортировка по столбцу 7 | 8 | select City, count(CustomerID) 9 | from Customers 10 | group by City 11 | HAVING count (CustomerID) >= 5 12 | 13 | select * 14 | from Customers 15 | order by City -------------------------------------------------------------------------------- /что выведет/область видимости/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := 2 9 | 10 | switch a { 11 | case 1: 12 | fmt.Println("one") 13 | case 2: 14 | fmt.Println("two") 15 | fallthrough 16 | case 3: 17 | fmt.Println("three") 18 | fallthrough 19 | default: 20 | fmt.Println("default") 21 | } 22 | } -------------------------------------------------------------------------------- /что выведет/область видимости/3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | a := 5 9 | switch { 10 | case a > 1: 11 | fmt.Println("a > 1") 12 | fallthrough 13 | case a > 2: 14 | fmt.Println("a > 2") 15 | break 16 | case a > 3: 17 | fmt.Println("a > 3") 18 | default: 19 | fmt.Println("default") 20 | } 21 | } -------------------------------------------------------------------------------- /сети/модель tcp: -------------------------------------------------------------------------------- 1 | Уровень 1. Прикладной HTTP, RTSP, FTP, DNS 2 | Уровень 2. Транспортный напр., TCP, UDP, SCTP, DCCP 3 | Уровень 3. Сетевой (Межсетевой) Для TCP/IP это IP 4 | Уровень 4. Уровень сетевого доступа Ethernet, IEEE 802.11 WLAN, SLIP, Token Ring, ATM и MPLS, физическая среда и принципы кодирования информации, T1, E1 5 | 6 | 1 сторона спрашивает у 2, готова ли та принимать данные - SYN 7 | 2 сторона отвечает 1, согласие на принятие данных - SYN ACK 8 | -------------------------------------------------------------------------------- /algorythms/select_sort.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main(){ 6 | a := []int{6,7,4,8,0,121,4,5,} 7 | fmt.Println("after sort", a) 8 | select_sort(a) 9 | fmt.Println("before sort", a) 10 | 11 | } 12 | 13 | 14 | func select_sort(a []int){ 15 | len := len(a) 16 | 17 | for i:=0; i < len; i++{ 18 | minIndx := i 19 | for j := i; j < len; j++{ 20 | if a[j] < a[minIndx]{ 21 | minIndx = j 22 | } 23 | } 24 | a[i], a[minIndx] = a[minIndx], a[i] 25 | } 26 | } -------------------------------------------------------------------------------- /algorythms/interface.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type book struct { 8 | author string 9 | title string 10 | } 11 | 12 | func (a book) String() string { 13 | return a.author + a.title 14 | } 15 | 16 | type Chislo int 17 | 18 | func (a Chislo) String() string { 19 | return "hello world" 20 | } 21 | 22 | func write(s fmt.Stringer) { 23 | fmt.Println(s) 24 | } 25 | 26 | func main() { 27 | a := book{"zafar", "kahsanov"} 28 | b := Chislo(25) 29 | 30 | write(a) 31 | write(b) 32 | } 33 | -------------------------------------------------------------------------------- /основное/константы + iota: -------------------------------------------------------------------------------- 1 | "Const в Golang" 2 | 3 | "Что такое константы и можно ли их изменять?" 4 | Константы - это неизменяемые переменные, изменить константу нельзя. 5 | 6 | "Что такое iota?" 7 | iota - идентификатор, который позволяет создавать последовательные не типизированные целочисленные константы. 8 | Значением iota является индекс ConstSpec. Не смотря на то, что первым индексом является 0, 9 | значение первой константы можно задать отличным от 0, что в свою очередь повлияет на значения последующих констант. 10 | 11 | -------------------------------------------------------------------------------- /что выведет/threads/2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "time" 7 | ) 8 | 9 | func main() { 10 | timeout := 3 * time.Second 11 | ctx, cancel := context.WithTimeout(context.Background(), timeout) 12 | defer cancel() 13 | 14 | select { 15 | case <-time.After(1 * time.Second): 16 | fmt.Println("waited for 1 sec") 17 | case <-time.After(2 * time.Second): 18 | fmt.Println("waited for 2 sec") 19 | case <-time.After(3 * time.Second): 20 | fmt.Println("waited for 3 sec") 21 | case <-ctx.Done(): 22 | fmt.Println(ctx.Err()) 23 | } 24 | } -------------------------------------------------------------------------------- /algorythms/binary_search.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main(){ 8 | a := []int{1,2,3,4,5,6,7,8,9} 9 | b := 4 10 | fmt.Println("Searchin int is", b) 11 | fmt.Println("Index num is",binary_search(a,b)) 12 | } 13 | 14 | func binary_search(a []int, b int) int{ 15 | low := 0 16 | high := len(a) - 1 17 | 18 | 19 | for low <= high{ 20 | mid := (high + low) / 2 21 | guess := a[mid] 22 | if guess == b{ 23 | return mid 24 | } else if guess < b { 25 | low = mid + 1 26 | } else { 27 | high = mid - 1 28 | } 29 | } 30 | return 0 31 | } -------------------------------------------------------------------------------- /что выведет/interface/1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "container/heap" 5 | "fmt" 6 | ) 7 | 8 | type IntHeap []int 9 | 10 | func (h IntHeap) Len() int { return len(h) } 11 | func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } 12 | func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 13 | 14 | func (h *IntHeap) Push(x interface{}) { 15 | *h = append(*h, x.(int)) 16 | } 17 | 18 | func (h *IntHeap) Pop() interface{} { 19 | old := *h 20 | n := len(old) 21 | x := old[n-1] 22 | *h = old[0 : n-1] 23 | return x 24 | } 25 | 26 | func main() { 27 | h := &IntHeap{2, 1, 5} 28 | heap.Init(h) 29 | fmt.Printf("first: %d\n", (*h)) 30 | } -------------------------------------------------------------------------------- /базы данных/CAP теорема: -------------------------------------------------------------------------------- 1 | https://clck.ru/sUngP 2 | 3 | Теорема CAP (известная также как теорема Брюера) — эвристическое утверждение о том, что в любой реализации распределённых вычислений возможно обеспечить не более двух из трёх следующих свойств: 4 | 5 | согласованность данных (англ. consistency) — во всех вычислительных узлах в один момент времени данные не противоречат друг другу; 6 | 7 | доступность (англ. availability) — любой запрос к распределённой системе завершается корректным откликом, 8 | однако без гарантии, что ответы всех узлов системы совпадают; 9 | 10 | устойчивость к разделению (англ. partition tolerance) — расщепление распределённой системы на несколько изолированных секций 11 | не приводит к некорректности отклика от каждой из секций. -------------------------------------------------------------------------------- /algorythms/Merge Two Sorted Lists.go: -------------------------------------------------------------------------------- 1 | // https://leetcode.com/problems/merge-two-sorted-lists/ 2 | 3 | /** 4 | * Definition for singly-linked list. 5 | * type ListNode struct { 6 | * Val int 7 | * Next *ListNode 8 | * } 9 | */ 10 | func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode { 11 | res := new(ListNode) 12 | tmp := res 13 | 14 | for list1 != nil && list2 != nil{ 15 | if list1.Val < list2.Val{ 16 | tmp.Next = list1 17 | list1 = list1.Next 18 | } else { 19 | tmp.Next = list2 20 | list2 = list2.Next 21 | } 22 | tmp = tmp.Next 23 | } 24 | 25 | if list1 != nil{ 26 | tmp.Next = list1 27 | } else { 28 | tmp.Next = list2 29 | } 30 | return res.Next 31 | } 32 | 33 | -------------------------------------------------------------------------------- /algorythms/quick_sort.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math/rand" 6 | ) 7 | 8 | func main(){ 9 | a := []int{- 15, 123, 0 ,1233, -124234, 25, 6, 7, 2, 1, 0} 10 | fmt.Println(QuickSort(a)) 11 | } 12 | 13 | func QuickSort(a []int) []int { 14 | len := len(a) 15 | if len < 2{ 16 | return a 17 | } 18 | less := make([]int, 0, len) 19 | mid := make([]int, 0, len) 20 | greater := make([]int, 0, len) 21 | pivot := a[rand.Intn(len)] 22 | 23 | for _,i:=range(a){ 24 | switch{ 25 | case i < pivot: 26 | less = append(less, i) 27 | case i == pivot: 28 | mid = append(mid, i) 29 | case i > pivot: 30 | greater = append(greater, i) 31 | } 32 | } 33 | less, greater = QuickSort(less), QuickSort(greater) 34 | less = append(less, mid...) 35 | less = append(less, greater...) 36 | return less 37 | } 38 | -------------------------------------------------------------------------------- /algorythms/reverse_linked_list.go: -------------------------------------------------------------------------------- 1 | // https://leetcode.com/problems/reverse-linked-list/ 2 | 3 | /** 4 | * Definition for singly-linked list. 5 | * type ListNode struct { 6 | * Val int 7 | * Next *ListNode 8 | * } 9 | */ 10 | 11 | // Input: head = [1,2,3,4,5] 12 | // Output: [5,4,3,2,1] 13 | 14 | package main 15 | import "fmt" 16 | 17 | type ListNode struct { 18 | Val int 19 | Next *ListNode 20 | } 21 | 22 | func main(){ 23 | var a1, a2, a3 ListNode 24 | a1 = ListNode{Val: 25, Next: &a2} 25 | a2 = ListNode{Val: 15, Next: &a3} 26 | a3 = ListNode{Val: 5, Next: nil} 27 | fmt.Println(reverseList(&a1)) 28 | } 29 | 30 | func reverseList(head *ListNode) *ListNode { 31 | var res *ListNode 32 | 33 | for head != nil{ 34 | tmp := head.Next 35 | head.Next = res 36 | res = head 37 | head = tmp 38 | } 39 | return res 40 | } -------------------------------------------------------------------------------- /algorythms/remove_nth_node.go: -------------------------------------------------------------------------------- 1 | // https://leetcode.com/problems/remove-nth-node-from-end-of-list/ 2 | 3 | // Given the head of a linked list, remove the nth node from the end of the list and return its head. 4 | 5 | /** 6 | * Definition for singly-linked list. 7 | * type ListNode struct { 8 | * Val int 9 | * Next *ListNode 10 | * } 11 | */ 12 | 13 | // Input: head = [1,2,3,4,5], n = 2 14 | // Output: [1,2,3,5] 15 | 16 | func removeNthFromEnd(head *ListNode, n int) *ListNode { 17 | tmp := head 18 | countNode := 0 19 | for tmp != nil{ 20 | countNode++ 21 | tmp = tmp.Next 22 | } 23 | removePosition := countNode - n 24 | if n != 0{ 25 | if removePosition > 0 { 26 | tmp = head 27 | for i:=0;i медленные операции 14 | 15 | Нереляционные системы (NoSQL) — системы, созданные для определенных моделей данных, обладающие гибкими схемами. 16 | Иначе говоря, это БД, которые хранят данные не в виде табличных схем, строк и столбцов, а в иных форматах. 17 | Плюс : хранится в ram => быстрые операции 18 | Минус : малая вместимость 19 | 20 | Нормализация — это процесс организации, структуризации данных в базе, 21 | который обеспечивает большую гибкость базы данных за счет исключения избыточности и несогласованности зависимостей. 22 | 23 | Индекс — отсортированный набор значений, связанных с таблицей или представлением с конкретной колонкой, который ускоряет получение данных. 24 | Не стоит использовать, если в таблицу часто добавляются новые данные. 25 | Индекс является структурой дерева, соответственно прихоидится каждый раз пересчитываеть его. 26 | 27 | Первичный ключ (Primary key) — поле в таблице для идентификации каждой строки в таблице базы данных. 28 | В таблице может быть только одно такое поле, и все значения должны быть уникальными. 29 | 30 | Внешний ключ (Foreign key) — это свойство, создаваемое для того, чтобы обеспечить связь между таблицами. 31 | Как правило, внешний ключ устанавливается для столбцов в подчиненной таблице и указывает на один из столбцов из главной таблицы. 32 | 33 | Типы соединений между таблицами (Join) 34 | INNER JOIN — пересечение двух таблиц. 35 | соединение, которое показывает только те данные из первой таблицы, которым соответствуют некоторые данные из второй таблицы. Остальные — опускаются. 36 | LEFT JOIN — объединение по левой таблице. 37 | соединение, которое показывает все данные из первой таблицы и соответствующие данные из второй, если они есть. 38 | Если же соответствующих данных нет, поля для данных из второй таблицы будут пустыми. 39 | RIGHT JOIN — объединение по правой таблице. 40 | соединение, которое показывает все данные из второй таблицы и соответствующие данные из первой, если они есть. 41 | Если же соответствующих данных нет, поля для данных из первой таблицы будут пустыми. 42 | FULL JOIN — обхединение двух таблиц. 43 | соединение, которое показывает все данные из первой и второй таблицы. 44 | Если связанных данных в другой таблице нет, поля для этих данных будут пустыми. 45 | 46 | AСID 47 | A — Атомарность, гарантирует, что никакая транзакция не фиксируется в системе частично. Выполняются либо все её подоперации, либо ни одной. 48 | К примеру, перевод денег в банке на другой счет — это две операции: 49 | Перевести деньги на счет банка. 50 | Перевести деньги со счета банка на конкретный счет. 51 | Но может всякое случиться. Например, поступят в банк, а дальше выпадет какая-то ошибка и вторая операция не выполнится. Или наоборот: выполнится только вторая операция. Поэтому эти действия осуществляются в рамках одной транзакции, и в результате либо всё, либо ничего. 52 | 53 | С — Согласованность: каждая успешная транзакция всегда фиксирует только разрешаемые результаты. 54 | Это гарантирует, что все ограничения будут соблюдены (например, NOT NULL), иначе — транзакция откатится. 55 | 56 | И — изолированность: во время выполнения транзакции параллельные транзакции не должны оказывать влияние на ее результат. 57 | Это дает нам возможность скрывать от всех не конечные состояния данных. Собственно, поэтому неуспешные транзакции не могут ничего сломать. 58 | 59 | Д — долговечность: если транзакция выполнена, то можно быть уверенным, что внесенные ею изменения не отменятся из-за какого-либо сбоя. 60 | 61 | Аномалии БД 62 | Аномалии в базах данных - это необычные, нежелательные и неожиданные результаты, 63 | которые могут возникнуть в процессе доступа и изменения данных в базе данных. 64 | Они могут возникать при одновременном доступе к данным нескольких пользователей 65 | или при ошибочном использовании команд для изменения данных. 66 | 67 | Существует несколько типов аномалий данных: 68 | 1. Аномалия вставки (Insertion anomaly) - возникает, 69 | когда необходимо вставить новую строку в таблицу, 70 | но для этого необходимо указать значения для всех столбцов, включая те, 71 | которые не имеют отношения к новой строке. 72 | 73 | 2. Аномалия обновления (Update anomaly) - возникает, 74 | когда изменение данных в одной строке таблицы приводит к изменению данных в других строках. 75 | 76 | 3. Аномалия удаления (Deletion anomaly) - возникает, 77 | когда при удалении данных из таблицы удаляются также и данные, на которые ссылаются другие строки таблицы. 78 | Для предотвращения аномалий данных в базе данных необходимо правильно структурировать таблицы и 79 | использовать правильные типы связей между таблицами. 80 | Кроме того, необходимо следить за тем, чтобы все операции с данными выполнялись корректно и не приводили к возникновению аномалий. -------------------------------------------------------------------------------- /конкурентность в go/конкурентность в go: -------------------------------------------------------------------------------- 1 | Конкурентность в Golang 2 | https://clck.ru/sUEwK 3 | 4 | "Что такое асинхронность?" 5 | Вычисления в системе могут идти двумя способами: 6 | синхронно - это когда код выполняется последовательно; 7 | асинхронно - это когда операцию мы можем выполнять не дожидаясь результата на месте. 8 | Обычно подразумевается, что операция может быть выполнена кем-то на стороне. 9 | 10 | "Что такое параллельность?" 11 | Вычисления будут являться параллельным только в том случае, если они выполняются одновременно. 12 | Как пример можно привести процесс ремонта в доме. 13 | У нас есть несколько мастеров-универсалов, 14 | каждый из которых выполняет работы на своем объекте под ключ. 15 | При этом производительность мастеров не зависит друг от друга, 16 | так как их работа не пересекается. 17 | 18 | "Что такое процесс" 19 | Процесс - это экземпляр программы, которая запущена в операционной системе. 20 | Каждый процесс имеет свою собственную память и ресурсы, такие как файлы, сетевые соединения и т.д. 21 | Один процесс может запускать несколько потоков. 22 | 23 | "Что такое thread?" 24 | Поток - это легковесный подпроцесс, который работает внутри процесса. 25 | Каждый поток имеет свой собственный стек и указатель инструкций, 26 | но разделяет память и ресурсы с другими потоками внутри процесса. 27 | Потоки обычно используются для параллельной обработки задач внутри одного процесса 28 | и позволяют улучшить производительность приложения. 29 | 30 | "Разница процесса и потока" 31 | Разница между процессом и потоком заключается в том, что процесс - это экземпляр программы, 32 | который имеет свою собственную память и ресурсы, тогда как поток - это легковесный подпроцесс, 33 | который работает внутри процесса и разделяет память и ресурсы с другими потоками внутри процесса. 34 | 35 | "Что такое goroutine?" 36 | Горутина - реализация в Go корутины, блоков кода, которые работают асинхронно. 37 | Она объявляется через оператор go перед функцией, 38 | вычисления которой необходимо сделать асинхронными. 39 | На многоядерной архитектуре выполнение горутин можно осуществлять на разных ядрах процессора. 40 | Это сделает эти вычисления параллельными и может сильно ускорить вычисления. 41 | 42 | "Какие основные отличия горутины от thread?" 43 | Горутина : 44 | -Управляются рантаймом языка => Более высокоуровневая абстракция, поэтому не зависит от системы 45 | -Более легковесны => Имеет стэк, который может расти 46 | Поток : 47 | -Управляются процессорным ядром => Зависит от системы 48 | -Требуют большего количества ресурсов => Фиксированный стэк 49 | 50 | "Каков минимальный и максимальный вес горутин?" 51 | для x64 - 1гб 52 | для х32 - 250мб 53 | 54 | "Что будет если размер горутины превысил допустимый максимум?" 55 | Если размер стэка горутины превышен (к примеру запустили бесконечную рекурсию), то приложение упадет с fatal error. 56 | 57 | "Какое максимальное количество горутин может быть запущено в системе?" 58 | Количество горутин ограничено только оперативной памятью системы. 59 | 60 | "Что такое планировщик go?" 61 | Рантайм (runtime) — «обслуживающая» часть приложения, которая добавляется к коду приложения. 62 | Отвечает за взаимодействие с ОС, планированием выполнения приложения, сборку мусора и за другие поддерживающие операции. 63 | 64 | Планировщик — часть рантайма, которая управляет запуском и остановкой горутин, решает, 65 | в каком порядке будут выполняться горутины, осуществляет взаимодействие с тредами ОС. 66 | 67 | "Какие есть способы остановить все горутины в приложении?" 68 | завершение main функции и main горутины; 69 | 70 | прослушивание всеми горутинами channel, при закрытии channel отправляется значение по умолчанию всем слушателям, при получении сигнала все горутины делают return; 71 | 72 | завязать все горутины на переданный в них context. 73 | 74 | "Как наладить связь между горутинами?" 75 | Каналы обеспечивают возможность общения нескольких горутин друг с другом, чтобы синхронизировать их выполнение. 76 | 77 | Многопоточная работа - работа нескольких потоков. При этом не факт, что все потоки будут активны. 78 | Возможно, что работает один поток, а другой спит. Когда первый поток закончил работу, он может разбудить второй, а сам заснуть 79 | 80 | Распараллеливание - разбиение одной задачи на независимые подзадачи и выполнение этих подзадач одновременно разными потоками. 81 | Пример: вычисление среднего значения двумерного массива. Каждый поток может посчитать сумму своей строки, а потом все это объединить 82 | 83 | Асинхронная работа - когда мы ставим какую-то задачу, но не ждем ответа, а продолжаем делать свою работу. А когда будет готов ответ - нас уведомят. 84 | Пример: попросить секретаря сварить кофе. Мы не ждем этого кофе и занимаемся своими делами, а когда кофе будет готов - нам его принесут. 85 | 86 | "race condition что это" 87 | Race condition - это ситуация, когда два или более процесса или потока исполнения пытаются изменить общие ресурсы одновременно, 88 | что может привести к неожиданным и непредсказуемым результатам. 89 | 90 | Это происходит, когда порядок выполнения операций не определен, 91 | и разные процессы могут попытаться изменить один и тот же ресурс одновременно, 92 | что может привести к ошибкам в программе или к неправильным результатам. 93 | 94 | Например, если два потока одновременно пытаются увеличить значение переменной на единицу, 95 | то результат может быть непредсказуемым, так как оба потока могут прочитать изначальное значение переменной и увеличить его на единицу, 96 | но только одно из них сохранит измененное значение, что может привести к некорректному результату. 97 | 98 | Для предотвращения race condition необходимо использовать механизмы синхронизации, 99 | такие как блокировки, мьютексы и семафоры, чтобы гарантировать, 100 | что только один процесс или поток исполнения может изменять ресурс в определенный момент времени. 101 | 102 | "deadlock" 103 | Deadlock (заглушка) - это ситуация, которая возникает в многопоточном или распределенном приложении, 104 | когда два или более потока блокируют друг друга, ожидая освобождения ресурсов, 105 | которые заняты другими потоками. В результате ни один из потоков не может продолжить выполнение своих задач. 106 | 107 | Deadlock может возникнуть, когда два или более потока одновременно запрашивают ресурсы, 108 | которые уже заняты другими потоками, и не отпускают их, пока не получат доступ. 109 | В результате возникает зацикленная ситуация, когда каждый поток ждет, 110 | чтобы другой поток освободил ресурсы, которые ему нужны. 111 | 112 | Примером deadlock может быть ситуация, когда поток A заблокировал ресурс X и запрашивает доступ к ресурсу Y, 113 | который заблокировал поток B. В то же время поток B запрашивает доступ к ресурсу X, 114 | который заблокировал поток A. В результате оба потока блокируют друг друга и не могут продолжить выполнение своих задач. 115 | 116 | Для предотвращения deadlock необходимо использовать правильный подход к управлению ресурсами и блокировками. 117 | Например, можно использовать стратегии предоставления ресурсов, 118 | которые минимизируют конфликты и блокировки, или использовать алгоритмы, 119 | которые позволяют избежать зацикливания. 120 | Кроме того, можно использовать средства мониторинга и диагностики, 121 | которые позволяют обнаруживать и исправлять deadlock в реальном времени. 122 | --------------------------------------------------------------------------------