From 48a4d8367096fd2ceaad02017834c984d7246333 Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 20:25:15 +0300 Subject: [PATCH 1/6] update 02.7.md for turkish --- tr/02.7.md | 250 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 tr/02.7.md diff --git a/tr/02.7.md b/tr/02.7.md new file mode 100644 index 000000000..3ed9c757f --- /dev/null +++ b/tr/02.7.md @@ -0,0 +1,250 @@ +# Concurrency + +Go'nun 21. yüzyılın C'si olduğu söyleniyor. Bence bunun iki nedeni var. Birincisi, Go basit bir dil. İkincisi, eşzamanlılık günümüz dünyasında çok popüler bir konu ve Go bu özelliği dil seviyesinde destekliyor. + +## goroutine + +goroutine'ler ve eşzamanlılık Go'nun çekirdek tasarımında yer almaktadır. Thread'lere benzerler ancak farklı çalışırlar. Go ayrıca goroutinlerinizde bellek paylaşımı için tam destek sağlar. Bir goroutine genellikle 4~5 KB yığın bellek kullanır. Bu nedenle, tek bir bilgisayarda binlerce goroutine çalıştırmak zor değildir. Bir goroutine, sistem iş parçacıklarından daha hafif, daha verimli ve daha kullanışlıdır. + +goroutine'ler Go'da çalışma zamanında iş parçacığı yöneticisi üzerinde çalışır. Temel düzeyde bir fonksiyon olan yeni bir goroutine oluşturmak için `go` anahtar sözcüğünü kullanırız ( ***main() bir goroutine'dir*** ). +```Go +go hello(a, b, c) +``` +Bir örnek görelim. +```Go +package main + +import ( + "fmt" + "runtime" +) + +func say(s string) { + for i := 0; i < 5; i++ { + runtime.Gosched() + fmt.Println(s) + } +} + +func main() { + go say("dünya") // yeni bir goroutine oluşturun + say("merhaba") // mevcut goroutine +} + +``` +Çıktı： +``` + merhaba + dünya + merhaba + dünya + merhaba + dünya + merhaba + dünya + merhaba +``` +Go'da `go` anahtar kelimesini kullanarak eşzamanlılığı kullanmanın çok kolay olduğunu görüyoruz. Yukarıdaki örnekte, bu iki goroutin bir miktar bellek paylaşmaktadır, ancak tasarım tarifini takip etmemiz daha iyi olacaktır: İletişim kurmak için paylaşılan verileri kullanmayın, veri paylaşmak için iletişimi kullanın. + +`runtime.Gosched()`, CPU'nun diğer goroutinleri yürütmesine ve bir noktada geri gelmesine izin vermek anlamına gelir. + +Go 1.5'te, çalışma zamanı artık `GOMAXPROCS` tarafından tanımlanan aynı anda çalışacak varsayılan iş parçacığı sayısını CPU'daki mevcut çekirdek sayısına göre ayarlamaktadır. + +Go 1.5'ten önce, zamanlayıcı tüm goroutinleri çalıştırmak için yalnızca bir iş parçacığı kullanır, bu da yalnızca eşzamanlılığı uyguladığı anlamına gelir. Paralel işlemeden yararlanmak için daha fazla CPU çekirdeği kullanmak istiyorsanız, kullanmak istediğiniz çekirdek sayısını ayarlamak için runtime.`GOMAXPROCS(n)` komutunu çağırmanız gerekir. Eğer `n<1` ise, hiçbir şey değişmez. + +## channels + +goroutinler aynı bellek adres alanında çalışır, bu nedenle paylaşılan belleğe erişmek istediğinizde senkronizasyonu sürdürmeniz gerekir. Farklı goroutinler arasında nasıl iletişim kurarsınız? Go, `channel` adı verilen çok iyi bir iletişim mekanizması kullanır. Bir `channel` Unix kabuklarındaki iki yönlü boru hattı gibidir: veri göndermek veya almak için `channel` kullanın. Kanallarda kullanılabilecek tek veri tipi `channel` tipi ve `chan` anahtar kelimesidir. Yeni bir `kanal` oluşturmak için `make` kullanmanız gerektiğini unutmayın. +```Go +ci := make(chan int) +cs := make(chan string) +cf := make(chan interface{}) +``` +kanalı veri göndermek veya almak için `<-` operatörünü kullanır. +```Go +ch <- v // v'yi kanal ch'ye gönderin. +v := <-ch // ch'den veri alır ve v'ye atar +``` +Daha fazla örnek görelim. +```Go +package main + +import "fmt" + +func sum(a []int, c chan int) { + total := 0 + for _, v := range a { + total += v + } + c <- total // toplamı c'ye gönder +} + +func main() { + a := []int{7, 2, 8, -9, 4, 0} + + c := make(chan int) + go sum(a[:len(a)/2], c) + go sum(a[len(a)/2:], c) + x, y := <-c, <-c // toplamı c'den al + + fmt.Println(x, y, x+y) +} + +``` +Kanallarda veri gönderme ve alma varsayılan olarak bloklanır, bu nedenle senkron goroutinleri kullanmak çok daha kolaydır. Bloktan kastım, bir goroutinin boş bir kanaldan veri alırken, yani (`value := <-ch`), diğer goroutinler bu kanala veri gönderene kadar devam etmeyeceğidir. Öte yandan, goroutine bir kanala gönderdiği veri, yani (`ch<-5`), alınana kadar devam etmeyecektir. + +## Buffered channels + +Yukarıda tamponlanmamış kanalları tanıttım. Go aynı zamanda tek bir elemandan daha fazlasını saklayabilen tamponlu kanallara da sahiptir. Örneğin, `ch := make(chan bool, 4)`, burada 4 boolean elemanı saklayabilen bir kanal oluşturuyoruz. Yani bu kanalın içine bloklama olmadan 4 eleman gönderebiliyoruz, ancak beşinci bir eleman göndermeye çalıştığınızda ve hiçbir goroutine bunu almadığında goroutine bloklanacaktır. +```Go +ch := make(chan type, n) + +n == 0 ! non-buffer（block） +n > 0 ! buffer（non-block until n elements in the channel） +``` +Aşağıdaki kodu bilgisayarınızda deneyebilir ve bazı değerleri değiştirebilirsiniz. +```Go +package main + +import "fmt" + +func main() { + c := make(chan int, 2) // 2'yi 1 olarak değiştirirseniz çalışma zamanı hatası olur, ancak 3 iyidir + c <- 1 + c <- 2 + fmt.Println(<-c) + fmt.Println(<-c) +} + +``` +## Range and Close + +Dilim ve eşlemede olduğu gibi tampon kanallar üzerinde çalışmak için aralığı kullanabiliriz. +```Go +package main + +import ( + "fmt" +) + +func fibonacci(n int, c chan int) { + x, y := 1, 1 + for i := 0; i < n; i++ { + c <- x + x, y = y, x+y + } + close(c) +} + +func main() { + c := make(chan int, 10) + go fibonacci(cap(c), c) + for i := range c { + fmt.Println(i) + } +} + +``` +`for i := range c` kanal kapatılana kadar kanaldan veri okumayı durdurmayacaktır. Yukarıdaki örnekte kanalı kapatmak için `close` anahtar sözcüğünü kullanıyoruz. Kapalı bir kanalda veri göndermek veya almak imkansızdır; bir kanalın kapalı olup olmadığını test etmek için `v, ok := <-ch` kullanabilirsiniz. Eğer `ok` false döndürürse, bu kanalda veri olmadığı ve kanalın kapalı olduğu anlamına gelir. + +Kanalları her zaman tüketicilerde değil üreticilerde kapatmayı unutmayın, aksi takdirde panik durumuna geçmek çok kolaydır. + +Hatırlamanız gereken bir başka şey de kanalların dosyalar gibi olmadığıdır. Kanalın tamamen yararsız olduğundan emin değilseniz veya aralık döngülerinden çıkmak istemiyorsanız, bunları sık sık kapatmanız gerekmez. + +## Select + +Yukarıdaki örneklerde sadece bir kanal kullandık, ancak birden fazla kanalla nasıl başa çıkabiliriz? Go, birçok kanalı dinlemek için `select` adlı bir anahtar kelimeye sahiptir. + +`select` varsayılan olarak engelleyicidir ve yalnızca kanallardan birinde gönderilecek veya alınacak veri olduğunda çalışmaya devam eder. Aynı anda birden fazla kanal kullanıma hazırsa, select hangisinin çalıştırılacağını rastgele seçer. +```Go +package main + +import "fmt" + +func fibonacci(c, quit chan int) { + x, y := 1, 1 + for { + select { + case c <- x: + x, y = y, x+y + case <-quit: + fmt.Println("quit") + return + } + } +} + +func main() { + c := make(chan int) + quit := make(chan int) + go func() { + for i := 0; i < 10; i++ { + fmt.Println(<-c) + } + quit <- 0 + }() + fibonacci(c, quit) +} + +``` +`select`in de tıpkı `switch` gibi bir `default` durumu vardır. Tüm kanallar kullanıma hazır olmadığında, varsayılan durumu çalıştırır (artık kanalı beklemez). +```Go +select { +case i := <-c: +// use i +default: +// executes here when c is blocked +} +``` +## Timeout + +Bazen bir goroutine bloke olur. Tüm programın bloke olmasını önlemek için bunu nasıl önleyebiliriz? Çok basit, select içinde bir zaman aşımı ayarlayabiliriz. +```Go +func main() { + c := make(chan int) + o := make(chan bool) + go func() { + for { + select { + case v := <-c: + println(v) + case <-time.After(5 * time.Second): + println("timeout") + o <- true + break + } + } + }() + <-o +} + +``` +## Runtime goroutine + +`runtime` paketi goroutine'lerle çalışmak için bazı fonksiyonlara sahiptir. + +- `runtime.Goexit()` + + Geçerli goroutine'den çıkar, ancak ertelenen işlevler her zamanki gibi yürütülür. + +- `runtime.Gosched()` + + Zamanlayıcının diğer goroutinleri yürütmesine ve bir noktada geri gelmesine izin verir. + +- `runtime.NumCPU() int` + + CPU çekirdeği sayısını döndürür + +- `runtime.NumGoroutine() int` + + Goroutin sayısını döndürür + +- `runtime.GOMAXPROCS(n int) int` + + Kaç CPU çekirdeği kullanmak istediğinizi ayarlar + +## Links + +- [Directory](preface.md) +- Önceki bölüm: [interface](02.6.md) +- Sonraki bölüm: [Summary](02.8.md) From 9de95b09d70dc91f88e2366b448d12fbd7f9690f Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 20:34:36 +0300 Subject: [PATCH 2/6] update 02.8.md for Turkish --- tr/02.8.md | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 tr/02.8.md diff --git a/tr/02.8.md b/tr/02.8.md new file mode 100644 index 000000000..bc907e8cb --- /dev/null +++ b/tr/02.8.md @@ -0,0 +1,32 @@ +# 2.8 Özet + +Bu bölümde temel olarak 25 Go anahtar kelimesini tanıttık. Şimdi bunların ne olduklarını ve ne işe yaradıklarını gözden geçirelim. +```Go + break default func interface select + case defer go map struct + chan else goto package switch + const fallthrough if range type + continue for import return var +``` +- `var` ve `const` değişkenleri ve sabitleri tanımlamak için kullanılır. +- `package` ve `import` paket kullanımı içindir. +- `func` fonksiyonları ve metotları tanımlamak için kullanılır. +- `return` fonksiyonlarda veya metotlarda değer döndürmek için kullanılır. +- `defer`, defer fonksiyonlarını tanımlamak için kullanılır. +- `go` yeni bir goroutine başlatmak için kullanılır. +- `select` iletişim için birden fazla kanal arasında geçiş yapmak için kullanılır. +- `interface` arayüzleri tanımlamak için kullanılır. +- `struct` özel özelleştirilmiş türleri tanımlamak için kullanılır. +- `break`, `case`, `continue`, `for`, `fallthrough`, `else`, `if`, `switch`, `goto` ve `default` bölüm 2.3'te tanıtılmıştır. +- `chan` goroutinler arasındaki iletişim için kullanılan kanal türüdür. +- `type` özelleştirilmiş türleri tanımlamak için kullanılır. +- `map` diğer dillerdeki hash tablolarına benzeyen map tanımlamak için kullanılır. +- `range`, `slice`, `map` ve `channel`'dan veri okumak için kullanılır. + +Bu 25 anahtar kelimeyi nasıl kullanacağınızı anladıysanız, Go hakkında çok şey öğrenmişsiniz demektir. + +## Bağlantılar + +- [Directory](preface.md) +- Önceki bölüm: [Eşzamanlılık](02.7.md) +- Sonraki bölüm: [Web vakfı](03.0.md) From 284c9d1b8e25399a06e7b0b08a26267c78569d53 Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 20:42:14 +0300 Subject: [PATCH 3/6] update next and previous title --- tr/02.7.md | 4 ++-- tr/02.8.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tr/02.7.md b/tr/02.7.md index 3ed9c757f..36cebb066 100644 --- a/tr/02.7.md +++ b/tr/02.7.md @@ -246,5 +246,5 @@ func main() { ## Links - [Directory](preface.md) -- Önceki bölüm: [interface](02.6.md) -- Sonraki bölüm: [Summary](02.8.md) +- Önceki bölüm: [Interface - Arayüz](02.6.md) +- Sonraki bölüm: [Summary - Özet](02.8.md) diff --git a/tr/02.8.md b/tr/02.8.md index bc907e8cb..b831220ba 100644 --- a/tr/02.8.md +++ b/tr/02.8.md @@ -25,7 +25,7 @@ Bu bölümde temel olarak 25 Go anahtar kelimesini tanıttık. Şimdi bunların Bu 25 anahtar kelimeyi nasıl kullanacağınızı anladıysanız, Go hakkında çok şey öğrenmişsiniz demektir. -## Bağlantılar +## Links - [Directory](preface.md) - Önceki bölüm: [Eşzamanlılık](02.7.md) From c99eff076bc5ef8af7a85a0ed3acac2444772c1f Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 20:47:19 +0300 Subject: [PATCH 4/6] update title --- tr/02.7.md | 20 ++++++++++---------- tr/02.8.md | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/tr/02.7.md b/tr/02.7.md index 36cebb066..e205a35b3 100644 --- a/tr/02.7.md +++ b/tr/02.7.md @@ -1,8 +1,8 @@ -# Concurrency +# Concurrency - Eşzamanlılık Go'nun 21. yüzyılın C'si olduğu söyleniyor. Bence bunun iki nedeni var. Birincisi, Go basit bir dil. İkincisi, eşzamanlılık günümüz dünyasında çok popüler bir konu ve Go bu özelliği dil seviyesinde destekliyor. -## goroutine +## Goroutine goroutine'ler ve eşzamanlılık Go'nun çekirdek tasarımında yer almaktadır. Thread'lere benzerler ancak farklı çalışırlar. Go ayrıca goroutinlerinizde bellek paylaşımı için tam destek sağlar. Bir goroutine genellikle 4~5 KB yığın bellek kullanır. Bu nedenle, tek bir bilgisayarda binlerce goroutine çalıştırmak zor değildir. Bir goroutine, sistem iş parçacıklarından daha hafif, daha verimli ve daha kullanışlıdır. @@ -52,7 +52,7 @@ Go 1.5'te, çalışma zamanı artık `GOMAXPROCS` tarafından tanımlanan aynı Go 1.5'ten önce, zamanlayıcı tüm goroutinleri çalıştırmak için yalnızca bir iş parçacığı kullanır, bu da yalnızca eşzamanlılığı uyguladığı anlamına gelir. Paralel işlemeden yararlanmak için daha fazla CPU çekirdeği kullanmak istiyorsanız, kullanmak istediğiniz çekirdek sayısını ayarlamak için runtime.`GOMAXPROCS(n)` komutunu çağırmanız gerekir. Eğer `n<1` ise, hiçbir şey değişmez. -## channels +## Channels - Kanallar goroutinler aynı bellek adres alanında çalışır, bu nedenle paylaşılan belleğe erişmek istediğinizde senkronizasyonu sürdürmeniz gerekir. Farklı goroutinler arasında nasıl iletişim kurarsınız? Go, `channel` adı verilen çok iyi bir iletişim mekanizması kullanır. Bir `channel` Unix kabuklarındaki iki yönlü boru hattı gibidir: veri göndermek veya almak için `channel` kullanın. Kanallarda kullanılabilecek tek veri tipi `channel` tipi ve `chan` anahtar kelimesidir. Yeni bir `kanal` oluşturmak için `make` kullanmanız gerektiğini unutmayın. ```Go @@ -93,7 +93,7 @@ func main() { ``` Kanallarda veri gönderme ve alma varsayılan olarak bloklanır, bu nedenle senkron goroutinleri kullanmak çok daha kolaydır. Bloktan kastım, bir goroutinin boş bir kanaldan veri alırken, yani (`value := <-ch`), diğer goroutinler bu kanala veri gönderene kadar devam etmeyeceğidir. Öte yandan, goroutine bir kanala gönderdiği veri, yani (`ch<-5`), alınana kadar devam etmeyecektir. -## Buffered channels +## Buffered Channels - Tamponlanmış Kanallar Yukarıda tamponlanmamış kanalları tanıttım. Go aynı zamanda tek bir elemandan daha fazlasını saklayabilen tamponlu kanallara da sahiptir. Örneğin, `ch := make(chan bool, 4)`, burada 4 boolean elemanı saklayabilen bir kanal oluşturuyoruz. Yani bu kanalın içine bloklama olmadan 4 eleman gönderebiliyoruz, ancak beşinci bir eleman göndermeye çalıştığınızda ve hiçbir goroutine bunu almadığında goroutine bloklanacaktır. ```Go @@ -117,7 +117,7 @@ func main() { } ``` -## Range and Close +## Range and Close - Aralık ve Kapanış Dilim ve eşlemede olduğu gibi tampon kanallar üzerinde çalışmak için aralığı kullanabiliriz. ```Go @@ -151,7 +151,7 @@ Kanalları her zaman tüketicilerde değil üreticilerde kapatmayı unutmayın, Hatırlamanız gereken bir başka şey de kanalların dosyalar gibi olmadığıdır. Kanalın tamamen yararsız olduğundan emin değilseniz veya aralık döngülerinden çıkmak istemiyorsanız, bunları sık sık kapatmanız gerekmez. -## Select +## Select - Seçim Yukarıdaki örneklerde sadece bir kanal kullandık, ancak birden fazla kanalla nasıl başa çıkabiliriz? Go, birçok kanalı dinlemek için `select` adlı bir anahtar kelimeye sahiptir. @@ -196,7 +196,7 @@ default: // executes here when c is blocked } ``` -## Timeout +## Timeout - Zaman Aşımı Bazen bir goroutine bloke olur. Tüm programın bloke olmasını önlemek için bunu nasıl önleyebiliriz? Çok basit, select içinde bir zaman aşımı ayarlayabiliriz. ```Go @@ -219,7 +219,7 @@ func main() { } ``` -## Runtime goroutine +## Runtime Goroutine - Çalışma Zamanı `runtime` paketi goroutine'lerle çalışmak için bazı fonksiyonlara sahiptir. @@ -243,8 +243,8 @@ func main() { Kaç CPU çekirdeği kullanmak istediğinizi ayarlar -## Links +## Links - Linkler - [Directory](preface.md) -- Önceki bölüm: [Interface - Arayüz](02.6.md) +- Önceki bölüm: [Interface - Arabirim](02.6.md) - Sonraki bölüm: [Summary - Özet](02.8.md) diff --git a/tr/02.8.md b/tr/02.8.md index b831220ba..ab37e2981 100644 --- a/tr/02.8.md +++ b/tr/02.8.md @@ -25,7 +25,7 @@ Bu bölümde temel olarak 25 Go anahtar kelimesini tanıttık. Şimdi bunların Bu 25 anahtar kelimeyi nasıl kullanacağınızı anladıysanız, Go hakkında çok şey öğrenmişsiniz demektir. -## Links +## Linkler - [Directory](preface.md) - Önceki bölüm: [Eşzamanlılık](02.7.md) From d029a8a58dc911d9d7d3b8c44cb1c2bc55ee9f23 Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 21:17:09 +0300 Subject: [PATCH 5/6] update title --- tr/02.7.md | 4 ++-- tr/02.8.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tr/02.7.md b/tr/02.7.md index e205a35b3..5b2eac398 100644 --- a/tr/02.7.md +++ b/tr/02.7.md @@ -243,8 +243,8 @@ func main() { Kaç CPU çekirdeği kullanmak istediğinizi ayarlar -## Links - Linkler +## Linkler -- [Directory](preface.md) +- [İçerik](preface.md) - Önceki bölüm: [Interface - Arabirim](02.6.md) - Sonraki bölüm: [Summary - Özet](02.8.md) diff --git a/tr/02.8.md b/tr/02.8.md index ab37e2981..7411129c3 100644 --- a/tr/02.8.md +++ b/tr/02.8.md @@ -27,6 +27,6 @@ Bu 25 anahtar kelimeyi nasıl kullanacağınızı anladıysanız, Go hakkında ## Linkler -- [Directory](preface.md) +- [İçerik](preface.md) - Önceki bölüm: [Eşzamanlılık](02.7.md) - Sonraki bölüm: [Web vakfı](03.0.md) From 223aefaad688807c9317ea8b9848d25af8d238ed Mon Sep 17 00:00:00 2001 From: mstgnz Date: Fri, 12 Jan 2024 21:50:57 +0300 Subject: [PATCH 6/6] update next section --- tr/02.8.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tr/02.8.md b/tr/02.8.md index 7411129c3..c31e87eeb 100644 --- a/tr/02.8.md +++ b/tr/02.8.md @@ -29,4 +29,4 @@ Bu 25 anahtar kelimeyi nasıl kullanacağınızı anladıysanız, Go hakkında - [İçerik](preface.md) - Önceki bölüm: [Eşzamanlılık](02.7.md) -- Sonraki bölüm: [Web vakfı](03.0.md) +- Sonraki bölüm: [Web Temel Kuruluşu](03.0.md)