2016-03-30 16 views
1

Aşağıdaki kod örneği, her seferinde 1 iş parçacığının etkin bir şekilde çalışmasına izin verir. Konulara referanslar tutmak ve daha sonra 'Thread.join' çağırmak daha sonra aynı etkiye sahiptir. Bu iş parçacığı, iş parçacığının bağımsız olarak ve paralel olarak devam etmesini bekleyen programla nasıl çalışacak ve sonra çıkacak? Diğer bazı Kernel nesne sinyalizasyon mekanizmalarının kullanılması gerektiği anlaşılıyor. 'Programdan çıkmadan önce birden çok iş parçacığının tamamlanmasını beklemenin doğru yolu C++ 11

int main() { 
    while (cin) { 
     getline(cin, input_line); 
     if (input_line.length()>0) 
     { 
      thread t = thread(SomeLengthyCheck, input_line); 
      t.join(); 
     } 
    } 
} 
+0

" 'katılmak' diğer iş parçacığı aynı anda çalışmasına izin vermeyen bir ikincil iş parçacığı ana iş parçacığı kravat kullanarak o11c @ önerdiği ?" - bu varsayım yanlıştır. Sadece bir saniye uyumak için birden fazla iş parçacığı başlat. Ardından, tüm bu konulara katılın ve genel programın ne kadar sürdüğünü izleyin. –

+0

@Ulrich Yukarıdaki kod parçamdan bahsediyordum, çünkü while döngüsündeki 'thread.join' çağrısının etkisi diğer thread'ları bile başlatmıyordu .. Tüm threadlar oluşturulduktan sonra bir birleşim kullanmak diğer thread'lara izin verirdi tamamlanana kadar devam edin (aşağıda açıklandığı gibi). Ayrıca, ana iş parçacığı çıktıktan sonra bile iş parçacığının devam etmesi gerektiğini belirten spekülasyonları anlıyorum, ancak bu yaklaşımla ilgili rahat değilim ... – Gio

cevap

1

Genel olarak bir iş parçacığı dizisi kullanırsınız, ardından bunların tümünü bir for döngüsünde beklersiniz.

Sonunda, hepsinin bitirmesi gerektiği gibi, siparişi aldırmazsınız.

Sizin durumunuzda, kaç iş parçacığının beklemesi gerektiğini bilmediğiniz için bir iş parçacığı yığınına/sıraya ihtiyacınız olacaktır.

int main() { 
    std::vector<std::thread> threads; 
    std::string input_line; 
    while (getline(std::cin, input_line)) { 
     if (input_line.length()>0) { 
      threads.push_back(std::thread(SomeLengthyCheck, input_line)); 
     } 
    } 
    for (auto& th : threads) th.join();  
} 

DÜZENLEME: İstisna güvenli sürümü Kısacası

class vthreads : std::vector<std::thread> { 
    ~vthreads() { for (auto& th : *this) th.join(); } 
}; 

int main() { 
    vthreads threads; 
    std::string input_line; 
    while (getline(std::cin, input_line)) { 
     if (input_line.length()>0) { 
      threads.push_back(std::thread(SomeLengthyCheck, input_line)); 
     } 
    } 
} 
+1

Ancak bu durum istisna değildir. Aramayı otomatik olarak çağrılacak olan bir yıkıcıya ".join" olarak koymak daha iyidir. – o11c

+0

@ o11c İyi yakalama, buna cevabı ekledi. – xvan

0

ben linux ile uzman değilim (kısa kullanırken? Diğer iş parçacığı aynı anda çalışmasına izin vermeyen bir ikincil iş parçacığı ana iş parçacığı kravat 'katılmak') ama ipler main bağlıdırlar düşünüyorum Ana iş parçacığının eşzamansız olarak çalışan herhangi bir iş parçacığı işlem görecek şekilde işlenirken, ana makinede return süreci ve bağlı tüm çocuk konuları kapatın.

Else ben çağıran fonksiyon bu global değişkenle gerçekleştiğinde Ana sürecine işaret olabilir çevreleyen {}

sonra tamamlandığında ipler sona erecek inanıyoruz.

Ayrıca, birleştirme hakkında kafanız karışmış olduğunu düşünüyorum. Birleştir, bir araya getirilen iş parçacığı, bitirilecek olana kadar arama iş parçacığı durdurarak esas olarak eşzamanlı olarak çalışacak şekilde eşzamansız bir iş parçacığı (işlev) zorlar.

+0

Bir genel işlemin iş parçacıkları, bir ana işlemin iş parçacıklarının aynı bellek kaynaklarını paylaşması nedeniyle çalışmalıdır. –

+0

Davranış Linux tarafından değil, C++ standardıyla tanımlanmıştır. Bu standart aynı zamanda, bir "std :: thread" öğesinin ayrıştırıcı çağrısından önce ayrılması veya birleştirilmesi gerektiğini de söyler. “Std :: thread” 'in oluşturulduğu alanı bırakarak, ikisinden de ikisi de abort()' a bir çağrıya neden oluyor. –

İlgili konular