Python Programming

Veri Yoğun Uygulamalar için Python'da Eşzamanlılık: AsyncIO vs Çoklu İşlem

By admin · Mar 22, 2026 · 28 views 🤖 AI
programmingconcurrencyperformancepythonmultiprocessingasynciodata-intensive

Veri yoğun uygulamaların karmaşıklığının ve ölçeğinin artmaya devam etmesiyle birlikte, optimal performans sağlamak isteyen geliştiriciler için Python'un eşzamanlılık modellerini anlamak kritik hale gelmektedir. API çağrıları, veritabanı sorguları veya dosya işlemleri gibi G/Ç sınırlı görevler içeren işlemlerle uğraşırken doğru eşzamanlılık yaklaşımını seçmek, uygulamanızın verimliliği ve kaynak kullanımı üzerinde önemli bir etki yaratabilir.

Python Eşzamanlılık Modellerini Anlamak

Python, G/Ç sınırlı işlemler için AsyncIO ve CPU sınırlı görevler için Multiprocessing olmak üzere iki temel yaklaşım sunar. Her yaklaşım farklı amaçlar için hizmet verir ve belirli senaryolarda üstünlük sağlar.

AsyncIO: Asenkron Programlamanın Gücü

AsyncIO, async/await sözdizimini kullanarak eşzamanlı kod yazmak için Python'un yerleşik kütüphanesidir. Özellikle dış kaynaklar için beklerken zaman harcayan görevler için oldukça etkilidir.

import asyncio
import aiohttp
import time

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def fetch_multiple_urls(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

# Örnek kullanım
urls = [
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/1',
    'https://httpbin.org/delay/1'
]

start_time = time.time()
results = asyncio.run(fetch_multiple_urls(urls))
end_time = time.time()
print(f"{len(urls)} URL'yi {end_time - start_time:.2f} saniyede getirdi")

Asenkron programlama, görevlerin ağ yanıtları, veritabanı sorguları veya dosya G/Ç'si için beklediği senaryolarda parlayan bir yaklaşımdır. Temel avantajı, bir koro başka bir koro çalışırken kontrolü verip, eşzamanlı olarak yürütülmesine izin vermesidir.

Multiprocessing: Birden Fazla Çekirdeği Kullanmak

Multiprocessing, her biri kendi Python yorumlayıcısı ve bellek alanına sahip olan ayrı Python yorumlayıcı süreçleri oluşturur. Bu yaklaşım, aynı anda birden fazla CPU çekirdeğini kullanmak istediğiniz CPU sınırlı işlemler için uygundur.

import multiprocessing as mp
import time
import math

def cpu_intensive_task(n):
    # CPU yoğun işi simüle eder
    result = 0
    for i in range(n):
        result += math.sqrt(i)
    return result

def process_chunk(data_chunk):
    return [cpu_intensive_task(x) for x in data_chunk]

def parallel_processing_example(data):
    # Her işlem için veriyi parçalara ayır
    chunk_size = len(data) // mp.cpu_count()
    chunks = [data[i:i + chunk_size] for i in range(0, len(data), chunk_size)]
    
    with mp.Pool() as pool:
        results = pool.map(process_chunk, chunks)
    
    # Sonuçları düzleştir
    flattened = [item for sublist in results for item in sublist]
    return flattened

# Örnek kullanım
data = list(range(10000, 100000, 1000))
start_time = time.time()
results = parallel_processing_example(data)
end_time = time.time()
print(f"{len(data)} öğe {end_time - start_time:.2f} saniyede işlendi")

AsyncIO ve Multiprocessing Seçimi

Bu iki yaklaşım arasında seçim yapmak, iş yükünüzün doğasına bağlıdır:

  • AsyncIO şunlarda üstünlük sağlar: Ağ istekleri, veritabanı işlemleri, dosya G/Ç'si ve programın harici kaynaklar için beklediği herhangi bir işlem.
  • Multiprocessing şunlarda parlayan: Matematiksel hesaplamalar, görüntü işleme, veri analizi ve CPU yoğun algoritmalar.

Karmaşık Uygulamalar için Hibrit Yaklaşımlar

Çoğu gerçek dünya uygulaması, her iki yaklaşımı da birleştirmekten fayda görür:

import asyncio
import multiprocessing as mp
from concurrent.futures import ProcessPoolExecutor
import aiohttp
import time

async def fetch_and_process(session, url):
    # Veriyi asenkron olarak al
    async with session.get(url) as response:
        data = await response.text()
    
    # Veriyi multiprocessing kullanarak işle
    with ProcessPoolExecutor() as executor:
        result = executor.submit(cpu_intensive_calculation, data)
        return result.result()

def cpu_intensive_calculation(data):
    # CPU sınırlı işlem
    return len(data) ** 2

async def hybrid_example():
    urls = [
        'https://httpbin.org/delay/1',
        'https://httpbin.org/delay/1',
        'https://httpbin.org/delay/1'
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_and_process(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

# Bu yaklaşım her iki dünyanın en iyisini birleştirir
async def main():
    start_time = time.time()
    results = await hybrid_example()
    end_time = time.time()
    print(f"Hibrit yaklaşım {end_time - start_time:.2f} saniyede tamamlandı")
    print(f"Sonuçlar: {results}")

# asyncio.run(main())

Performans Düşünceleri ve En İyi Uygulamalar

Her iki yaklaşım da dikkat edilmesi gereken performans etkileri taşır. AsyncIO, minimum aşırı yük sunar ancak engelleme işlemlerinden kaçınmak için dikkatli tasarım gerektirir. Multiprocessing, süreç oluşturma ve süreçler arası iletişim nedeniyle daha fazla aşırı yük taşır ama çok çekirdekli sistemleri tamamen kullanabilir.

Sonuç

Veri yoğun uygulamalar için AsyncIO ve Multiprocessing arasında seçim yapmak, iş yükünüzün özelliklerini anlamayı gerektirir. G/Ç sınırlı işlemler için bekleme sıklığı yüksekse AsyncIO tercih edilirken, birden fazla çekirdek üzerinde paralel yürütme gerektiren CPU sınırlı görevler için Multiprocessing idealdir. Karmaşık uygulamalar için her iki modelin avantajlarını kullanacak bir hibrit yaklaşım düşünülebilir. Başarı için, özel kullanım durumunuzu profilleme yapmak ve uygulamanızın kritik noktalarına göre uygun eşzamanlılık modelini seçmek önemlidir.

Share:
Related Posts