09.12.2024

Python’da Çoklu İşlemi Anlamak: Basitleştirilmiş Bir Kılavuz

Yoğun kaynak gerektiren uygulamalar veya veri işleme görevleri mi yürütüyorsunuz? AlexHost’un Özel Sunucuları, Python’da çoklu işlemin gücünden yararlanmak için mükemmel bir ortam sağlar. Yüksek performanslı CPU’lar, özel kaynaklar ve sağlam altyapı ile AlexHost, uygulamalarınızın ağır hesaplama yükleri altında bile verimli çalışmasını sağlar. İster veri topluyor, ister simülasyonlar çalıştırıyor veya makine öğrenimi modelleri kullanıyor olun, AlexHost’un çözümleri üretkenliğinizi en üst düzeye çıkarmak için özel olarak tasarlanmıştır.

Python’un çoklu işlem modülü, birden fazla işlemi eşzamanlı olarak çalıştırmanıza olanak tanıyarak birden fazla CPU çekirdeğini kullanmayı ve CPU’ya bağlı görevlerin performansını artırmayı mümkün kılar. Bu, özellikle veri işleme, makine öğrenimi veya simülasyonlar gibi hesaplama açısından yoğun görevleriniz olduğunda kullanışlıdır. Bu kılavuz, Python’da çoklu işlemenin nasıl çalıştığı ve nasıl etkili bir şekilde kullanılacağı hakkında basitleştirilmiş bir açıklama sağlar.

Neden Çoklu İşlem Kullanılmalı?

Python, aynı anda yalnızca bir iş parçacığının Python bayt kodunu yürütmesine izin veren bir Global Yorumlayıcı Kilidi (GIL) kullanır. Bu, çok çekirdekli bir işlemcide bile aynı anda yalnızca bir iş parçacığı çalışabileceğinden, CPU’ya bağlı görevler için çoklu iş parçacığı kullanmayı zorlaştırır. Öte yandan çoklu işlem, her işlem için ayrı bellek alanları oluşturarak her işlemin paralel olarak yürütülmesine ve birden fazla CPU çekirdeğinden tam olarak yararlanmasına olanak tanır.

Çoklu İşlem ve Çoklu İş Parçacığı Arasındaki Temel Farklar:

Çoklu işlem: GIL’i atlayarak ve gerçek paralelliğe izin vererek her işlem için ayrı bellek alanları kullanır.
Multithreading: İş parçacıkları arasında bellek alanını paylaşır, ancak Python’daki GIL ile sınırlıdır, bu da onu G / Ç’ye bağlı görevler (dosya okuma / yazma veya ağ istekleri gibi) için daha uygun hale getirir.

Çoklu İşlem Modülü ile Başlarken

Python’un çoklu işlem modülü, birden fazla işlem oluşturmak ve yönetmek için çeşitli yollar sağlar. Aşağıda bazı temel kavramlar ve bunların nasıl kullanılacağı yer almaktadır:

Modülü İçe Aktarma

Çoklu işlem kullanmak için modülü içe aktarın:

içe aktar çoklu işlem

Çoklu İşlemin Temel Kavramları

Süreç: Süreç, bir programın bağımsız bir örneğidir. Python bağlamında, her sürecin kendi bellek alanı vardır.
Havuz: Havuz, sabit sayıda çalışan süreçle birden fazla süreci yönetmenize olanak tanır.
Kuyruk: Kuyruk, süreçler arasındaki iletişim için kullanılır.
Kilit: Kilit, işlemlerin paylaşılan kaynaklara aynı anda erişmesini önlemek için kullanılır.

Örnek 1: Basit Bir Süreç Oluşturma

Bir süreç oluşturmanın en temel yolu Process sınıfını kullanmaktır. İşte basit bir örnek:

from multiprocessing import Süreç

def print_numbers():
for i in range(5):
print(f “Sayı: {i}”)

if __name__ == “__main__”:
# Bir Süreç Oluşturun
process = Process(target=print_numbers)

# Süreci Başlatın
process.start()

# İşlemin tamamlanmasını bekleyin
process.join()

print(“İşlem tamamlandı.”)

Süreç: Process sınıfı yeni bir süreç oluşturmak için kullanılır.
target: Target bağımsız değişkeni, sürecin çalıştırması gereken işlevi belirtir.
start(): Süreci başlatır.
join(): Kodun geri kalanıyla devam etmeden önce işlemin tamamlanmasını bekler.

Bu örnekte, print_numbers işlevi ayrı bir süreçte çalışacak ve ana programın eşzamanlı olarak çalışmasına izin verecektir.

Örnek 2: Multiprocessing.Pool kullanımı

Pool sınıfı, çalışan süreçlerden oluşan bir havuzu yönetmek ve bir işlevi paralel olarak birden fazla veri öğesine uygulamak istediğinizde kullanışlıdır. İşte bir örnek:

from multiprocessing import Havuz

def kare_sayı(n):
n * n döndür

if __name__ == “__main__”:
# 4 süreçli bir Havuz oluştur
pool(4) ile havuz olarak:
numbers = [1, 2, 3, 4, 5]
# İşlevi listedeki her öğeye uygulamak için pool.map() işlevini kullanın
sonuçlar = pool.map(kare_sayı, sayılar)

print(f “Karesi alınmış sayılar: {sonuçlar}”)

Havuz: Çalışan süreçlerden oluşan bir havuz oluşturur. Bu durumda, 4 süreç oluşturur.
map(): Map işlevi bir işlev ve bir yinelenebilir (liste gibi) alır ve işlevi her öğeye paralel olarak uygular.

Bu örnek, sayılar listesindeki her sayıyı 4 paralel işlem kullanarak kareler. Pool.map() işlevi, işi mevcut işlemler arasında böler ve sonuçları bir liste olarak döndürür.

Örnek 3: İşlemler Arası İletişim için Kuyruk Kullanımı

İşlemlerin iletişim kurması veya veri paylaşması gerekiyorsa, bir Kuyruk kullanabilirsiniz. Bu, özellikle bir üretici-tüketici senaryosuna sahip olduğunuzda kullanışlıdır.

from multiprocessing import Process, Queue

def producer(queue):
for i in range(5):
queue.put(i)
print(f “Üretildi: {i}”)

def consumer(queue):
while not queue.empty():
item = queue.get()
print(f “Tüketildi: {öğe}”)

if __name__ == “__main__”:
queue = Queue()

# Üretici ve tüketici süreçleri oluşturun
producer_process = Process(target=producer, args=(queue,))
consumer_process = Process(target=consumer, args=(queue,))

# Her iki işlemi de başlatın
producer_process.start()
consumer_process.start()

# Her iki işlemin de bitmesini bekleyin
producer_process.join()
consumer_process.join()

print(“Tüm öğeler işlendi.”)

Kuyruk: Kuyruk, süreçler arasında veri aktarmak için kullanılır.
put(): Kuyruğa bir öğe ekler.
get(): Kuyruktan bir öğe alır.

Bu örnekte, üretici kuyruğa öğeler ekler, tüketici ise bu öğeleri alır ve işler.

Örnek 4: Yarış Koşullarını Önlemek için Kilitleri Kullanma

Birden fazla işlem bir kaynağı (bir dosya veya değişken gibi) paylaştığında, işlemlerin kaynağa aynı anda erişmeye çalıştığı yarış koşullarıyla karşılaşabilirsiniz. Kaynağa aynı anda yalnızca bir işlemin erişebilmesini sağlamak için bir Kilit kullanabilirsiniz.

from multiprocessing import Süreç, Kilit

def print_numbers(lock):
lock.acquire()
dene:
for i in range(5):
print(f “Sayı: {i}”)
nihayet:
lock.release()

if __name__ == “__main__”:
lock = Lock()

# İki süreç oluşturun
process1 = Process(target=print_numbers, args=(lock,))
process2 = Process(target=print_numbers, args=(lock,))

# İşlemleri başlatın
process1.start()
process2.start()

# Her iki işlemin de bitmesini bekleyin
process1.join()
process2.join()

print(“Her iki işlem de tamamlandı.”)

Kilit: Kodun kritik bir bölümüne aynı anda yalnızca bir sürecin erişebilmesini sağlar.
acquire(): Kilidi elde eder.
release(): Kilidi serbest bırakır.

Bu örnekte Kilit, process1 ve process2’nin sayıları aynı anda yazdırmasını engelleyerek çıktının iç içe geçmemesini sağlar.

Çoklu İşlem Ne Zaman Kullanılır?

CPU’ya Bağlı Görevler: Sayısal simülasyonlar, veri işleme veya şifreleme gibi çok fazla hesaplama gerektiren görevler için çoklu işlemeyi kullanın.
Paralel İşleme: Büyük bir dosya listesini işlemek gibi birden fazla veri parçası üzerinde aynı işlemi gerçekleştirmeniz gerektiğinde.
Kaynak İzolasyonu: Her işlemin kendi bellek alanına ihtiyacı olduğunda veya diğerlerinden tamamen izole edilmesi gerektiğinde.

Sonuç

Python’da çoklu işlem, birden fazla işlemi paralel olarak çalıştırmanın güçlü bir yoludur ve CPU’ya bağlı görevler için idealdir. Süreçler, havuzlar, kuyruklar ve kilitlerin temel kavramlarını anlayarak verimli ve etkili paralel programlar tasarlayabilirsiniz. İster büyük veri kümelerini işlemeniz, ister hesaplama açısından yoğun hesaplamalar yapmanız veya işlemler arası iletişimi yönetmeniz gereksin, Python’un çoklu işlem modülü ihtiyacınız olan araçları sağlar.