Go’nun context Paketi: Doğru Kullanım Kılavuzu

Modern Go uygulamaları geliştirirken, eşzamanlılık ve hata yönetimi kaçınılmaz zorluklardır. Peki, uzun süren bir işlem devam ederken kullanıcı isteğini iptal etmek, veritabanı sorgusuna bir zaman aşımı uygulamak veya mikroservisler arasında işlem kimliği taşımak gibi durumları nasıl ele alırsınız? İşte tam bu noktada, Go’nun context paketi devreye girerek bu karmaşık senaryoları zarif ve etkili bir şekilde yönetmenizi sağlar.

Go, eşzamanlılığı goroutine’ler ve kanallar aracılığıyla oldukça kolaylaştırır. Ancak, bir goroutine’in başlattığı bir işi durdurma, belirli bir süre sonra otomatik olarak iptal etme veya bir istek boyunca geçerli olacak verileri güvenli bir şekilde aktarma ihtiyacı doğduğunda işler karmaşıklaşabilir. Geleneksel yaklaşımlar genellikle karmaşık kanal yapıları veya global durumlar gerektirirken, context paketi bu tür zorluklar için standartlaştırılmış, hafif ve güçlü bir çözüm sunar. Özellikle web sunucuları, veritabanı işlemleri veya diğer uzun süreli arka plan görevleri gibi dağıtık sistemlerde, işlemlerin yaşam döngüsünü yönetmek ve kaynak sızıntılarını önlemek kritik öneme sahiptir. Örneğin, bir kullanıcı bir web sayfasını kapatırsa, o istekle ilgili devam eden tüm arka plan işlemlerinin de durdurulması performansı artırır ve gereksiz kaynak tüketimini engeller. Aksi takdirde, iptal edilmeyen goroutine’ler bellekte birikerek uygulamanızın performansını düşürebilir ve beklenmedik hatalara yol açabilir. Bu nedenle, context paketi sadece kodunuzu daha okunabilir ve sürdürülebilir hale getirmekle kalmaz, aynı zamanda Go uygulamalarınızın dayanıklılığını ve verimliliğini de artırır.

Bu paket, temelde dört ana işlevi destekler:

• İptal Sinyali Verme: Bir işlemin veya goroutine’in harici bir olay (örneğin kullanıcı isteğinin iptali) nedeniyle durdurulması gerektiğini bildirme.
• Zaman Aşımı Belirleme: Bir işlemin belirli bir süre içinde tamamlanmaması durumunda otomatik olarak iptal edilmesini sağlama.
• Son Tarih Belirleme: Bir işlemin belirli bir tarih veya saate kadar tamamlanması gerektiğini bildirme.
• İstek Kapsamlı Veri Aktarımı: Bir isteğin yaşam döngüsü boyunca (örneğin bir HTTP isteği) o isteğe özgü verileri (örneğin kullanıcı kimliği veya işlem izleme kimliği) güvenli bir şekilde taşıma.

Bu yetenekler sayesinde, eşzamanlı çalışan çok sayıda goroutine’in uyumlu bir şekilde iş birliği yapması ve birbirlerini gerektiğinde durdurabilmesi mümkün olur. Böylece uygulamanız daha kararlı hale gelir ve gereksiz yere kaynak tüketmez. Kısacası, Go’da sağlam ve ölçeklenebilir uygulamalar geliştirmek istiyorsanız, context paketini anlamak ve doğru kullanmak temel bir gerekliliktir.

context.Context Nedir ve Temel İşlevleri Nelerdir?

context.Context, Go dilinde eşzamanlı işlemler arasında iptal sinyalleri, zaman aşımı bilgileri ve istek kapsamlı verileri taşıyan bir arayüzdür. Aslında, bu arayüz sadece dört ana metot tanımlar ve bu metotların her biri belirli bir amaca hizmet eder. Bu arayüzün basitliği, onun esnekliğini ve Go ekosistemindeki yaygın kabulünü açıklar. Her Context, bir ağaç yapısındaki düğüm gibidir; bir Context‘ten türetilen (child) diğer Context‘ler, ebeveynlerinin özelliklerini miras alır ve ebeveyn iptal edildiğinde otomatik olarak iptal olurlar.

context.Context arayüzünün metotları şunlardır:

• Done() <-chan struct{}: Bu metot, context iptal edildiğinde veya zaman aşımına uğradığında kapanan bir kanal döndürür. Goroutine'ler bu kanalı dinleyerek iptal sinyalini alabilir ve işlerini temiz bir şekilde durdurabilirler. Kanalın kapanması, bir olayın gerçekleştiğini gösteren yaygın bir Go modelidir.
• Err() error: Done() kanalı kapandığında, bu metot context'in neden iptal edildiğini (örneğin, context.Canceled veya context.DeadlineExceeded) belirten bir hata döndürür. Bu hata, işlemin hangi koşullar altında durdurulduğunu anlamak için önemlidir.
• Deadline() (deadline time.Time, ok bool): Bu metot, context'in bir zaman aşımı veya son tarih ile yapılandırılıp yapılandırılmadığını ve yapılandırıldıysa ne zaman sona ereceğini belirtir. Eğer bir son tarih tanımlanmışsa ok değeri true olur ve deadline değeri de set edilmiş olur.
• Value(key any) any: Bu metot, context ile ilişkili istek kapsamlı veriye erişim sağlar. Veriler anahtar-değer çiftleri şeklinde saklanır ve genellikle tracing ID'leri, yetkilendirme token'ları veya diğer isteğe özgü meta verileri taşımak için kullanılır. Bu metot, değerin var olup olmadığını kontrol etmek için nil döndürebilir.

context paketi, bu temel arayüz etrafında çeşitli türetilmiş Context'ler oluşturmak için fonksiyonlar sunar. Bu fonksiyonlar, kök Context'lerden (context.Background() ve context.TODO()) başlayarak, iptal edilebilir, zaman aşımı olan veya değer taşıyan Context'ler yaratır. Bu hiyerarşik yapı, dağıtık sistemlerde bir isteğin başlangıcından sonuna kadar tüm ilgili işlemlerin kolayca izlenmesini ve yönetilmesini sağlar. Ayrıca, context paketinin sağladığı temiz API sayesinde, kodunuz daha az hata eğilimli ve daha anlaşılır hale gelir, böylece ekip üyeleri arasında işbirliği de kolaylaşır.

context Paketi Temelleri: Hangi Fonksiyonları Bilmeliyiz?

context paketinin gücünü kullanmak için bilmeniz gereken birkaç temel fonksiyon bulunmaktadır. Bu fonksiyonlar, farklı ihtiyaçlara yönelik olarak Context nesneleri oluşturmanıza olanak tanır ve Go uygulamalarınızın eşzamanlılık yönetimini bir üst seviyeye taşır. Her bir fonksiyon, belirli bir senaryoyu ele almak üzere tasarlanmıştır ve doğru yerde doğru fonksiyonu kullanmak, kodunuzun performansını ve güvenilirliğini önemli ölçüde artırır. Aşağıda, bu temel fonksiyonları ve kullanım amaçlarını detaylıca inceleyelim.

context.Background() ve context.TODO(): Başlangıç Noktaları

Her Go uygulamasında, context hiyerarşisinin bir başlangıç noktası olması gerekir. İşte bu noktada context.Background() ve context.TODO() devreye girer. Her ikisi de temelde boş bir Context döndürse de, kullanım amaçları farklıdır ve doğru seçimi yapmak, kodunuzun niyetini açıkça belirtmenize yardımcı olur.

• context.Background(): Bu, Go uygulamanızın ana Context'idir. Genellikle, belirli bir yaşam döngüsüne veya isteğe bağlı olmayan, programın ana goroutine'inden veya testlerden başlayan tüm çağrılarda kullanılır. Örneğin, uygulamanız başladığında tek seferlik bir başlangıç işlevi çağırıyorsanız veya bir goroutine'i tamamen bağımsız çalıştırmak istiyorsanız bu Context'i kullanırsınız. İptal edilemez, zaman aşımı yoktur ve herhangi bir değer taşımaz. Genellikle, bir Context'e ihtiyaç duyduğunuz ancak daha spesifik bir gereksiniminiz olmadığında iyi bir varsayılan seçimdir.

  
  package main
  
  import (
  	"context"
  	"fmt"
  	"time"
  )
  
  func main() {
  	// context.Background() ile bağımsız bir işlem başlatma
  	ctx := context.Background()
  
  	select {
  	case <-ctx.Done():
  		fmt.Println("Bu context asla iptal olmaz (Background)")
  	case <-time.After(1 * time.Second):
  		fmt.Println("1 saniye geçti, Background context hala aktif.")
  	}
  }
        

• context.TODO(): Bu fonksiyonun ismi, geliştiriciye "yapılacaklar listesinde" olduğunu hatırlatır. Yani, henüz net bir Context'in ne olması gerektiğine karar vermediğinizde, ancak yine de bir Context parametresi gerektiren bir fonksiyonu çağırmanız gerektiğinde geçici olarak kullanılır. Genellikle kodda bir yer tutucu olarak işlev görür ve daha sonra uygun bir Context ile değiştirilmesi beklenir. Eğer bir Context'e ihtiyacınız varsa fakat "ne kullanacağımı bilmiyorum" diyorsanız context.TODO() kullanmak, kodunuzu okuyan diğer geliştiricilere burada bir iyileştirme veya tasarım kararı beklediğinizi bildirir. Tıpkı Background() gibi, bu Context de iptal edilemez, zaman aşımı yoktur ve değer taşımaz.

  
  package main
  
  import (
  	"context"
  	"fmt"
  	"time"
  )
  
  func doSomething(ctx context.Context) {
  	select {
  	case <-ctx.Done():
  		fmt.Println("İşlem iptal edildi:", ctx.Err())
  	case <-time.After(500 * time.Millisecond):
  		fmt.Println("Do something completed.")
  	}
  }
  
  func main() {
  	// Geliştirme aşamasında geçici olarak context.TODO() kullanma
  	fmt.Println("context.TODO() ile bir işlem başlatılıyor...")
  	doSomething(context.TODO())
  	time.Sleep(1 * time.Second) // İşlemin tamamlanması için bekle
  }
        

Her iki fonksiyon da temel olarak aynı boş Context'i döndürse de, aralarındaki fark niyetlerindedir. Background() uygulamanın kökü için bilinçli bir seçimken, TODO() bir yer tutucudur ve gelecekteki bir iyileştirmeyi işaret eder. Bu ayrımı anlamak, Go projelerinizde daha anlamlı ve bakımı kolay kod yazmanıza yardımcı olacaktır.

İptal Mekanizmaları: WithCancel ile Nasıl Çalışılır?

context.WithCancel fonksiyonu, bir Context hiyerarşisinde manuel olarak iptal edilebilen yeni bir Context oluşturmanızı sağlar. Bu, uzun süreli bir işlem çalışırken, harici bir olay (örneğin kullanıcı arayüzünden bir iptal düğmesine basılması veya bir HTTP isteğinin bağlantısının kesilmesi) nedeniyle o işlemin durdurulması gerektiğinde son derece kullanışlıdır. WithCancel fonksiyonu iki değer döndürür: yeni türetilmiş Context ve bir CancelFunc. CancelFunc çağrıldığında, türetilmiş Context ve ondan daha da türetilmiş tüm Context'ler iptal sinyali alır.

package main

import (
	"context"
	"fmt"
	"time"
)

func performTask(ctx context.Context, taskID int) {
	fmt.Printf("Görev %d başladı...\n", taskID)
	select {
	case <-time.After(2 * time.Second):
		fmt.Printf("Görev %d tamamlandı.\n", taskID)
	case <-ctx.Done():
		// Context iptal edildiğinde burası tetiklenir
		fmt.Printf("Görev %d iptal edildi: %v\n", taskID, ctx.Err())
	}
}

func main() {
	// context.Background()'dan yeni bir iptal edilebilir context türet
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel() // main fonksiyonu sona erdiğinde cancel'ı çağır

	go performTask(ctx, 1)

	fmt.Println("1 saniye sonra görev 1'i iptal et.")
	time.Sleep(1 * time.Second)

	// Context'i iptal et
	cancel()

	// Biraz bekleyelim ki goroutine çıktısını görelim
	time.Sleep(500 * time.Millisecond)

	// Yeni bir görev başlat ama hemen iptal et
	ctx2, cancel2 := context.WithCancel(ctx) // iptal edilmiş ctx'ten türetmek hemen iptal eder
	defer cancel2()
	go performTask(ctx2, 2)
	fmt.Println("Görev 2 hemen iptal edildi çünkü ebeveyni iptaldi.")
	time.Sleep(100 * time.Millisecond)
}
  

Yukarıdaki örnekte, performTask adında uzun süren bir işlevi temsil eden bir goroutine başlatıyoruz. Bu goroutine, işini 2 saniyede bitirmeyi dener ancak aynı zamanda ctx.Done() kanalını da dinler. main fonksiyonunda 1 saniye bekledikten sonra cancel() fonksiyonunu çağırarak ctx'i iptal ederiz. Bu durum, performTask içindeki select bloğunun <-ctx.Done() durumunu tetiklemesine ve görevin erken sonlandırılmasına neden olur. defer cancel() kullanımı, kaynak sızıntılarını önlemek için kritik öneme sahiptir; çünkü CancelFunc çağrılmadığında, Context ile ilişkili goroutine'ler bellekte kalabilir ve gereksiz yere kaynak tüketebilir. İkinci örnekte ise, zaten iptal edilmiş bir Context'ten türetilen bir Context'in otomatik olarak iptal olduğunu gösterdik, bu da hiyerarşik yapının nasıl çalıştığını vurgular.

Zaman Sınırları Belirleme: WithTimeout ve WithDeadline Farkı Nedir?

Go'da eşzamanlı işlemlerde zaman yönetimi kritik bir konudur. Bir işlemin çok uzun sürmesi, sistem kaynaklarını tüketebilir ve kullanıcı deneyimini olumsuz etkileyebilir. context paketi, bu tür senaryolar için WithTimeout ve WithDeadline fonksiyonlarını sunar. Her ikisi de belirli bir süre sonra Context'in otomatik olarak iptal edilmesini sağlar, ancak kullanım biçimleri arasında önemli bir fark vardır.

• context.WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc):
  Bu fonksiyon, belirli bir time.Duration (örneğin 5 saniye, 300 milisaniye) sonra otomatik olarak iptal olacak bir Context oluşturur. Kullanımı kolaydır ve genellikle belirli bir işlem için maksimum izin verilen süreyi tanımlamanız gerektiğinde tercih edilir. Örneğin, bir HTTP isteği gönderirken veya bir veritabanı sorgusu yaparken belirli bir yanıt süresi bekliyorsanız idealdir.

  
  package main
  
  import (
  	"context"
  	"fmt"
  	"time"
  )
  
  func longRunningOperation(ctx context.Context, id int) {
  	fmt.Printf("Operasyon %d başladı...\n", id)
  	select {
  	case <-time.After(3 * time.Second):
  		fmt.Printf("Operasyon %d tamamlandı.\n", id)
  	case <-ctx.Done():
  		fmt.Printf("Operasyon %d zaman aşımına uğradı veya iptal edildi: %v\n", id, ctx.Err())
  	}
  }
  
  func main() {
  	// 2 saniyelik zaman aşımı ile bir context oluştur
  	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
  	defer cancel()
  
  	go longRunningOperation(ctx, 1)
  
  	fmt.Println("Ana fonksiyon bekliyor...")
  	time.Sleep(3 * time.Second) // longRunningOperation'dan daha uzun bekle
  }
        

  Yukarıdaki örnekte, longRunningOperation normalde 3 saniye sürerdi, ancak ctx'e 2 saniyelik bir zaman aşımı uyguladık. Bu nedenle, 2 saniye sonra ctx.Done() kanalı kapanacak ve operasyon zaman aşımı hatasıyla erken sonlandırılacaktır.

• context.WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc):
  Bu fonksiyon, belirli bir mutlak zaman noktasına (time.Time) kadar geçerli olacak bir Context oluşturur. Yani, "bu işlem şu saate kadar bitmeli" demek istediğinizde kullanılır. Örneğin, bir hizmetin SLA'sı (Hizmet Seviyesi Anlaşması) nedeniyle belirli bir mutlak son tarihe uymanız gerektiğinde veya sistem genelindeki bir zaman çizelgesine göre işlemlerinizi ayarlamanız gerektiğinde tercih edilebilir.

  
  package main
  
  import (
  	"context"
  	"fmt"
  	"time"
  )
  
  func fetchData(ctx context.Context, source string) {
  	fmt.Printf("Veri çekme işlemi '%s' başladı...\n", source)
  	select {
  	case <-time.After(1500 * time.Millisecond):
  		fmt.Printf("Veri çekme işlemi '%s' tamamlandı.\n", source)
  	case <-ctx.Done():
  		fmt.Printf("Veri çekme işlemi '%s' son tarihe ulaşıldığı için iptal edildi: %v\n", source, ctx.Err())
  	}
  }
  
  func main() {
  	// Şu andan 1 saniye sonraki bir son tarih belirle
  	deadline := time.Now().Add(1 * time.Second)
  	ctx, cancel := context.WithDeadline(context.Background(), deadline)
  	defer cancel()
  
  	go fetchData(ctx, "Uzak API")
  
  	fmt.Println("Ana fonksiyon son tarihi bekliyor...")
  	time.Sleep(1200 * time.Millisecond) // Biraz son tarihten sonra bekleyelim
  }
        

  Bu örnekte, fetchData işlemi normalde 1.5 saniye sürer, ancak ctx'i şu anki zamandan 1 saniye sonraki bir son tarihle ayarladık. Bu durumda, fetchData operasyonu tamamlanmadan son tarihe ulaşılacak ve işlem erken iptal edilecektir.

Her iki fonksiyon da bir CancelFunc döndürür ve bu fonksiyonun da defer ile çağrılması, yukarıda bahsedildiği gibi kaynak sızıntılarını önlemek adına hayati öneme sahiptir. Bu fonksiyonları doğru bir şekilde kullanarak, Go uygulamalarınızda eşzamanlı işlemlerin zamanında tamamlanmasını sağlayabilir, aksi takdirde oluşabilecek blokajları ve performans düşüşlerini engelleyebilirsiniz. Özellikle uzun süreli ağ çağrıları veya yoğun CPU kullanan hesaplamalar için bu mekanizmalar vazgeçilmezdir.

Gerçek Dünya Senaryoları: context ile Yaygın Problemleri Nasıl Çözeriz?

context paketi, Go'daki birçok gerçek dünya probleminin çözümünde merkezi bir rol oynar. Bu bölüm, paketin pratik uygulamalarını vaka analizleri ile detaylandıracak ve günlük geliştirme süreçlerinizde karşılaşabileceğiniz yaygın senaryolarda context'i nasıl kullanmanız gerektiğini gösterecektir. Dağıtık sistemlerden veritabanı işlemlerine kadar geniş bir yelpazede, context doğru kullanıldığında kodunuzu daha sağlam, ölçeklenebilir ve hata toleranslı hale getirir.

HTTP İsteklerinde Yaşam Döngüsü Yönetimi Nasıl Yapılır?

Web sunucuları, özellikle API geliştirmede, genellikle birçok eşzamanlı isteği işler. Her bir gelen HTTP isteği, kendi yaşam döngüsüne sahiptir ve bu yaşam döngüsü boyunca çeşitli arka plan işlemleri (veritabanı sorguları, diğer mikroservis çağrıları vb.) tetiklenebilir. Eğer istemci bağlantıyı kapatırsa veya istek zaman aşımına uğrarsa, sunucunun o istekle ilgili tüm devam eden işlemleri durdurması gerekir. Aksi takdirde, gereksiz hesaplama ve kaynak tüketimi yaşanır.

Go'nun net/http paketi, her gelen istekle (*http.Request) birlikte otomatik olarak bir Context sağlar. Bu Context, istemci bağlantısı kesildiğinde veya HTTP sunucusunun kendi zaman aşımı ayarlarına göre otomatik olarak iptal olur. Bu özelliği kullanarak, istekle ilgili tüm aşağı akış işlemlerini kolayca yönetebilirsiniz.

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"time"
)

// simulateDBQuery uzun süren bir veritabanı sorgusunu taklit eder
func simulateDBQuery(ctx context.Context, userID string) (string, error) {
	select {
	case <-time.After(3 * time.Second): // Normalde 3 saniye sürer
		return fmt.Sprintf("Kullanıcı %s için veriler alındı.", userID), nil
	case <-ctx.Done():
		// Context iptal edildiğinde veya zaman aşımına uğradığında
		return "", fmt.Errorf("DB sorgusu iptal edildi: %v", ctx.Err())
	}
}

func handler(w http.ResponseWriter, r *http.Request) {
	// İstek context'ini alıyoruz
	ctx := r.Context()

	// Opsiyonel: İstek context'ine ek bir zaman aşımı ekleyebiliriz
	// (örneğin, bu handler özelinde daha kısa bir zaman aşımı istiyorsak)
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
	defer cancel() // CancelFunc'ı çağırmayı unutmayın!

	userID := r.URL.Query().Get("user_id")
	if userID == "" {
		userID = "varsayilan_kullanici"
	}

	log.Printf("İstek başladı, user_id: %s", userID)

	data, err := simulateDBQuery(ctx, userID)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		log.Printf("İstek tamamlanamadı, user_id: %s, hata: %v", userID, err)
		return
	}

	fmt.Fprintf(w, "API Yanıtı: %s\n", data)
	log.Printf("İstek tamamlandı, user_id: %s", userID)
}

func main() {
	http.HandleFunc("/data", handler)

	// Sunucuya varsayılan bir okuma zaman aşımı (read timeout) ekleyebiliriz
	server := &http.Server{
		Addr:         ":8080",
		ReadTimeout:  5 * time.Second, // İstemcinin isteği gönderme süresi
		WriteTimeout: 5 * time.Second, // Sunucunun yanıtı yazma süresi
		IdleTimeout:  10 * time.Second,
	}

	log.Println("Sunucu 8080 portunda dinlemede...")
	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatalf("Sunucu başlatılırken hata oluştu: %v", err)
	}
}
  

Bu örnekte, handler fonksiyonu gelen HTTP isteğinin Context'ini alır ve bunu simulateDBQuery fonksiyonuna iletir. Eğer istemci 2 saniye içinde yanıt alamazsa (WithTimeout nedeniyle) veya bağlantıyı kapatırsa, simulateDBQuery otomatik olarak iptal sinyali alır ve veritabanı sorgusunu durdurur. Bu yaklaşım, sistem kaynaklarını korur ve istemciye zamanında geri bildirim sağlar. Aynı zamanda, context paketi sayesinde, bir isteğin yaşam döngüsü boyunca belirli verileri (örneğin kullanıcı kimliği, izleme kimliği) güvenli bir şekilde aktarmak için context.WithValue de kullanılabilir. Bu, hata ayıklama ve izleme yeteneklerini önemli ölçüde geliştirir. Örneğin, her isteğe benzersiz bir izleme kimliği atayıp bunu Context aracılığıyla tüm aşağı akış servislere iletebilirsiniz, böylece bir hata durumunda tüm ilgili logları kolayca ilişkilendirebilirsiniz.

Veritabanı ve Uzun Süreli İşlemlerde context'in Rolü Nedir?

Veritabanı işlemleri, özellikle yoğun yük altında veya yavaş ağ bağlantılarında, bazen beklenenden daha uzun sürebilir. Bu durum, uygulamanın blokajına, bağlantı havuzlarının tükenmesine ve nihayetinde hizmet kesintilerine yol açabilir. context paketi, bu tür sorunları ele almak için etkili bir mekanizma sunar. Go'daki çoğu veritabanı sürücüsü (database/sql paketi aracılığıyla), sorgu veya işlem metotlarına bir Context parametresi kabul eder. Bu, veritabanı işlemlerine zaman aşımı veya iptal yetenekleri eklemenizi sağlar.

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"time"

	_ "github.com/mattn/go-sqlite3" // Örnek için bir SQLite sürücüsü
)

// setupDBContext, veritabanı bağlantı havuzu ve context ile ilgili ayarları gösterir.
func setupDBContext() *sql.DB {
	db, err := sql.Open("sqlite3", ":memory:") // Bellek içi SQLite veritabanı
	if err != nil {
		log.Fatalf("Veritabanı açılamadı: %v", err)
	}

	// Tablo oluştur
	_, err = db.Exec("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)")
	if err != nil {
		log.Fatalf("Tablo oluşturulamadı: %v", err)
	}
	return db
}

func getUserByID(ctx context.Context, db *sql.DB, id int) (string, error) {
	var name string
	// Context'i sorgu metoduna iletiyoruz
	// Veritabanı sürücüsü, context'in iptal edildiğini algıladığında sorguyu iptal edebilir.
	err := db.QueryRowContext(ctx, "SELECT name FROM users WHERE id = ?", id).Scan(&name)
	if err != nil {
		return "", fmt.Errorf("kullanıcı ID %d sorgulanırken hata: %v", id, err)
	}
	return name, nil
}

func insertUser(ctx context.Context, db *sql.DB, id int, name, email string) error {
	_, err := db.ExecContext(ctx, "INSERT INTO users (id, name, email) VALUES (?, ?, ?)", id, name, email)
	if err != nil {
		return fmt.Errorf("kullanıcı eklenirken hata: %v", err)
	}
	return nil
}

func main() {
	db := setupDBContext()
	defer db.Close()

	// Bir kullanıcı ekleyelim
	err := insertUser(context.Background(), db, 1, "Alice", "alice@example.com")
	if err != nil {
		log.Fatalf("Kullanıcı ekleme hatası: %v", err)
	}

	// 1. senaryo: Başarılı sorgu
	ctx1, cancel1 := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel1()
	userName, err := getUserByID(ctx1, db, 1)
	if err != nil {
		log.Printf("Başarılı sorgu hatası: %v", err)
	} else {
		fmt.Printf("Kullanıcı adı: %s\n", userName)
	}

	// 2. senaryo: Zaman aşımına uğrayan sorgu (taklit)
	// Normalde veritabanı sorgusu hızlıdır, ancak uzun süren bir sorguyu taklit edelim
	// Bu örnekte, SQLite bellek içi olduğundan, gerçekten uzun sürmeyecektir.
	// Ancak, gerçek bir ağ tabanlı DB'de bu, ağ gecikmesi veya yavaş sorgu nedeniyle oluşabilir.
	ctx2, cancel2 := context.WithTimeout(context.Background(), 10*time.Millisecond) // Çok kısa zaman aşımı
	defer cancel2()

	// Uzun süren bir işlem taklidi
	go func() {
		// Gerçek bir DB sorgusunun uzun sürmesi durumunda ctx2.Done() dinlenir
		// Burada, QueryRowContext çağrısı, ctx2'nin zaman aşımına uğramasını bekleyecektir.
		_, err := getUserByID(ctx2, db, 1) // Bu sorgunun başarısız olması bekleniyor
		if err != nil {
			fmt.Printf("Zaman aşımı sorgu hatası (beklendiği gibi): %v\n", err)
		} else {
			fmt.Println("Zaman aşımı beklenirken sorgu tamamlandı! (Beklenmeyen durum)")
		}
	}()

	time.Sleep(50 * time.Millisecond) // Zaman aşımının tetiklenmesi için biraz bekle

	// 3. senaryo: Manuel iptal edilen sorgu
	ctx3, cancel3 := context.WithCancel(context.Background())
	go func() {
		_, err := getUserByID(ctx3, db, 1)
		if err != nil {
			fmt.Printf("Manuel iptal sorgu hatası (beklendiği gibi): %v\n", err)
		} else {
			fmt.Println("Manuel iptal beklenirken sorgu tamamlandı! (Beklenmeyen durum)")
		}
	}()

	fmt.Println("Manuel olarak sorguyu 20ms sonra iptal et...")
	time.Sleep(20 * time.Millisecond)
	cancel3()
	time.Sleep(10 * time.Millisecond) // İptalin işlenmesi için kısa bekleme
}
  

Yukarıdaki örnekte, getUserByID ve insertUser fonksiyonları bir Context parametresi kabul eder. QueryRowContext ve ExecContext gibi veritabanı metotları, bu Context'i kullanarak ilgili veritabanı işleminin iptal edilip edilmeyeceğini veya zaman aşımına uğrayıp uğramadığını kontrol eder. Örneğin, ctx2'ye çok kısa bir zaman aşımı (10 milisaniye) uygulandığında, getUserByID fonksiyonu veritabanı işlemini tamamlamadan önce Context zaman aşımına uğrar ve bir hata döndürülür. Bu sayede, yavaş veritabanı sorguları uygulamanın geri kalanını bloklamaz ve kaynakların gereksiz yere meşgul edilmesini önler.

Bu yaklaşım, özellikle mikroservis mimarilerinde veya çok sayıda harici servisle etkileşimde bulunan uygulamalarda hayati öneme sahiptir. Uzun süren veritabanı kilitleri veya ağ gecikmeleri nedeniyle bir servisin takılıp kalması yerine, context sayesinde bu işlemlerin kontrollü bir şekilde sonlandırılması sağlanır. Bu, uygulamanızın genel yanıt verme hızını ve kararlılığını artırır. Ayrıca, context.WithValue kullanarak bir veritabanı işlemine transaction ID'si veya kullanıcı oturum bilgileri gibi meta verileri eklemek, loglama ve hata ayıklama süreçlerini de kolaylaştırır.

En İyi Uygulamalar ve İleri Düzey Konular: context'i Daha Verimli Kullanmak

context paketini etkili bir şekilde kullanmak, sadece temel fonksiyonlarını bilmekle kalmaz, aynı zamanda Go programlamadaki bazı en iyi uygulamaları ve daha ileri düzey konuları da anlamayı gerektirir. Bu bölüm, context'i daha verimli kullanmanıza yardımcı olacak ipuçlarını, yaygın hatalardan kaçınma yollarını ve performans üzerindeki etkilerini ele alacaktır. Doğru kullanım, uygulamanızın daha sağlam, bakımı kolay ve performanslı olmasını sağlar.

context.WithValue Kullanımı: Veri Aktarımında Nelere Dikkat Etmeli?

context.WithValue fonksiyonu, bir Context'e istek kapsamlı, değişmez verileri eklemenizi sağlar. Bu, genellikle bir HTTP isteği boyunca kullanıcı kimliği, izleme kimliği (tracing ID), yetkilendirme bilgileri veya diğer meta verileri goroutine'ler arasında güvenli bir şekilde aktarmak için kullanılır. Ancak, bu fonksiyonu kullanırken dikkat etmeniz gereken önemli noktalar vardır:

• Sadece İsteğe Bağlı (Request-Scoped) Veriler İçin: WithValue, fonksiyon parametreleri yerine geçmemelidir. Global veya genel olarak erişilebilir veriler için kullanmayın. Sadece belirli bir isteğin yaşam döngüsü boyunca geçerli olan, opsiyonel ve kritik olmayan veriler için uygundur.
• Anahtar Türü: Çakışmaları önlemek için anahtar olarak dışa aktarılmamış (unexported) bir tür kullanın. Genellikle, boş bir yapı türü bu amaçla kullanılır. Bu, farklı paketlerin aynı anahtar değerini yanlışlıkla kullanmasını engeller.

  
  package main
  
  import (
  	"context"
  	"fmt"
  )
  
  // traceIDKey dışa aktarılmamış bir türdür, çakışmaları önler.
  type traceIDKey struct{}
  
  func processRequest(ctx context.Context) {
  	// context'ten traceID'yi al
  	if traceID, ok := ctx.Value(traceIDKey{}).(string); ok {
  		fmt.Printf("İstek işleniyor, Trace ID: %s\n", traceID)
  	} else {
  		fmt.Println("İstek işleniyor, Trace ID yok.")
  	}
  
  	// Bu context'i alt fonksiyonlara veya goroutine'lere ilet
  	// Örneğin, bir veritabanı çağrısı veya başka bir mikroservis çağrısı
  	go func(c context.Context) {
  		if subTraceID, ok := c.Value(traceIDKey{}).(string); ok {
  			fmt.Printf("Alt goroutine'de Trace ID: %s\n", subTraceID)
  		}
  	}(ctx)
  }
  
  func main() {
  	// Ana context'i oluştur
  	ctx := context.Background()
  
  	// context'e trace ID ekle
  	ctxWithTrace := context.WithValue(ctx, traceIDKey{}, "abc-123-xyz")
  
  	// İşlemi başlat
  	processRequest(ctxWithTrace)
  
  	// Trace ID olmayan bir işlem
  	fmt.Println("\nTrace ID'siz işlem:")
  	processRequest(ctx)
  
  	// Biraz bekleyelim ki goroutine çıktısını görelim
  	fmt.Println("Bekleniyor...")
  	// Eğer main sonlanırsa goroutine de sonlanır.
  	// Bu yüzden genellikle channel veya sync.WaitGroup ile goroutine'in bitmesi beklenir.
  	// Basitlik için burada eklemedim.
  }
        

• Değişmezlik: Context'e eklenen değerler değişmez olmalıdır. Context'ten alınan bir değeri değiştirmeye çalışmak, eşzamanlılık sorunlarına yol açabilir.
• Performans Etkisi: WithValue, hiyerarşik bir yapı oluşturur ve her değer erişimi, ağaçta yukarı doğru bir arama gerektirir. Aşırıya kaçmadan ve derin iç içe Context'ler oluşturmadan kullanmaya özen gösterin. Genellikle bu performans etkisi ihmal edilebilir düzeydedir, ancak çok sık ve derin arama yapılan senaryolarda göz önünde bulundurulmalıdır.

context'i Doğru Şekilde Fonksiyonlara Nasıl Geçirmeliyiz?

Go topluluğunda context.Context'in fonksiyonlara nasıl iletilmesi gerektiği konusunda yaygın kabul görmüş bir kural vardır:

• Her zaman ilk parametre olarak: Bir fonksiyonun context.Context'e ihtiyacı varsa, bu parametre her zaman fonksiyon imzasının ilk parametresi olmalıdır.

  
  // Doğru kullanım: ctx ilk parametre olarak
  func MyFunction(ctx context.Context, arg1 string, arg2 int) error {
      // ...
      return nil
  }
  
  // Yanlış kullanım: ctx son parametre veya arada bir yerde
  // func MyFunction(arg1 string, ctx context.Context, arg2 int) error { ... }
  // func MyFunction(arg1 string, arg2 int, ctx context.Context) error { ... }
        

• Fonksiyon parametresi olarak geçirin, yapı alanı olarak değil: Context'i bir struct'ın alanı olarak saklamaktan kaçının. Bunun yerine, ilgili metotlara parametre olarak geçirin. Context, belirli bir işlem akışı için geçerlidir ve genellikle bir nesnenin ömrü boyunca sabit kalmaz.

  
  // Doğru kullanım: Context metotlara parametre olarak geçer
  type Service struct {
      db *sql.DB
  }
  
  func (s *Service) GetUser(ctx context.Context, userID string) (*User, error) {
      // db.QueryRowContext(ctx, ...)
      return nil, nil
  }
  
  // Yanlış kullanım: Context'i struct içinde saklamak
  // type Service struct {
  //     ctx context.Context // Kötü pratik
  //     db  *sql.DB
  // }
        

• Boş Context Kullanımından Kaçının: Fonksiyonlar genellikle bir Context parametresi beklerken, doğrudan nil veya context.Background()'ı varsayılan olarak kullanmak yerine, çağrı yapanın uygun bir Context sağlamasını bekleyin. Eğer gerçekten bir Context'e ihtiyacınız yoksa, fonksiyon imzasında bu parametreyi bulundurmayın.

Bu kurallar, Go kodunuzun tutarlılığını artırır ve diğer Go geliştiricileri tarafından kolayca anlaşılmasını sağlar. Context'in amacına uygun kullanılması, uygulamanızın daha modüler ve test edilebilir olmasına da yardımcı olur. Ayrıca, bu yaklaşımlar, özellikle büyük ve karmaşık projelerde, kod tabanının genel kalitesini ve sürdürülebilirliğini artırır.

Özetle, context paketi Go'nun eşzamanlılık yeteneklerini yönetmek için temel bir araçtır. İptal, zaman aşımı ve veri aktarımı gibi kritik görevleri standartlaştırılmış ve temiz bir API ile sunar. Doğru kullanıldığında, Go uygulamalarınızın daha dirençli, performanslı ve bakımı kolay olmasını sağlar.

Sonuç

Go'nun context paketi, modern, eşzamanlı ve dağıtık uygulamalar geliştirirken karşılaşılan zorlukları ele almak için vazgeçilmez bir araçtır. Bu makalede, context'in neden bu kadar önemli olduğunu, temel fonksiyonlarını (Background, TODO, WithCancel, WithTimeout, WithDeadline, WithValue) ve gerçek dünya senaryolarında nasıl kullanıldığını detaylıca inceledik. Gelen HTTP isteklerinin yönetilmesinden veritabanı sorgularına zaman aşımı uygulanmasına kadar geniş bir yelpazede, context'in işlemlerin yaşam döngüsünü kontrol etme, kaynak sızıntılarını önleme ve istek kapsamlı verileri güvenli bir şekilde aktarma yeteneğini gördük. Ayrıca, paketin doğru ve verimli kullanımı için en iyi uygulamalar ve ileri düzey ipuçları üzerinde durarak, Go geliştiricilerinin daha sağlam ve bakımı kolay kod yazmalarına yardımcı olmayı hedefledik.

Unutmayın, context bir "silver bullet" değildir ve her zaman doğru çözüm olmayabilir, ancak Go ekosistemindeki yaygın kullanımı ve sağladığı faydalar göz önüne alındığında, her Go geliştiricisinin araç setinde bulunması gereken temel bir beceridir. Kodunuzda context'i bilinçli ve disiplinli bir şekilde kullanarak, eşzamanlılık sorunlarını daha etkin bir şekilde yönetebilir ve daha güvenilir uygulamalar inşa edebilirsiniz.

Sıkça Sorulan Sorular

• S: Hangi context'i ne zaman kullanmalıyım: Background() mı yoksa TODO() mu?

  C: context.Background(), uygulamanızın ana Context'idir ve genellikle belirli bir isteğe veya yaşam döngüsüne bağlı olmayan, en üst düzey operasyonlar için kullanılır. context.TODO() ise geçici bir yer tutucudur; henüz hangi Context'i kullanmanız gerektiğine karar vermediğinizde, ancak bir Context parametresi gerektiren bir fonksiyonu çağırmanız gerektiğinde kullanılır. Mümkün olduğunca Background() veya türetilmiş bir Context kullanın ve TODO()'yu sadece kısa süreli "yapılacaklar" için ayırın.

• S: context.CancelFunc'ı çağırmazsam ne olur?

  C: context.CancelFunc'ı çağırmamak, ilişkili Context ve onun altında türetilmiş tüm Context'lerle birlikte, Context hiyerarşisinde kaynak sızıntılarına yol açabilir. Bu, Context'in iptal sinyalini bekleyen goroutine'lerin süresiz olarak askıda kalmasına ve bellekte birikmesine neden olabilir. Bu nedenle, WithCancel, WithTimeout veya WithDeadline ile bir Context oluşturduğunuzda, döndürülen CancelFunc'ı genellikle bir defer ifadesiyle çağırmanız kritik öneme sahiptir.

• S: context.WithValue ile çok fazla veri aktarmak performans sorunu yaratır mı?

  C: context.WithValue, istek kapsamlı, küçük ve değişmez meta verileri aktarmak için tasarlanmıştır. Her Value() çağrısı, değerin bulunana kadar Context ağacında yukarı doğru bir arama yapar. Bu işlem genellikle çok hafiftir. Ancak, çok sayıda değeri veya büyük veri yapılarını Context aracılığıyla aktarmak, bu arama maliyetini artırabilir ve kodun okunabilirliğini azaltabilir. Genel kural, önemli veya isteğe bağlı argümanlar için doğrudan fonksiyon parametrelerini kullanmaktır. Context'i sadece tracing ID'leri, kimlik doğrulama bilgileri gibi küçük meta veriler için kullanın.

• S: Context'i neden bir struct alanı olarak saklamamalıyım?

  C: Bir Context, belirli bir işlem akışının veya isteğin yaşam döngüsüyle ilişkilidir ve zamanla iptal edilebilir veya zaman aşımına uğrayabilir. Bir Context'i bir struct alanı olarak saklamak, o struct'ı kullanan farklı operasyonların aynı, potansiyel olarak iptal edilmiş veya eski Context'i kullanmasına neden olabilir. Bu da beklenmeyen davranışlara veya hatalara yol açabilir. En iyi pratik, Context'i her zaman ilgili metotlara veya fonksiyonlara parametre olarak geçirmektir, böylece her işlem kendi uygun Context'ine sahip olur.