Jak czekać na zakończenie wątku w Objective-C

Question

Próbuję użyć metody z klasy pobranej gdzieś. Metoda jest wykonywana w tle, podczas gdy wykonywanie programu jest kontynuowane. Nie chcę zezwolić na wykonanie programu, dopóki ta metoda nie zostanie zakończona. Jak mogę to zrobić?

Answer 1

Proponuję zawinięcie wywołania metody klasy w twojej własnej metodzie i ustawienie wartości boolowskiej po jej zakończeniu. Dla np

BOOL isThreadRunning = NO; 
- (void)beginThread { 
    isThreadRunning = YES; 

    [self performSelectorInBackground:@selector(backgroundThread) withObject:nil]; 
} 
- (void)backgroundThread { 
    [myClass doLongTask]; 

    // Done! 
    isThreadRunning = NO; 
} 
- (void)waitForThread { 
    if (! isThreadRunning) { 
     // Thread completed 
     [self doSomething]; 
    } 
} 

Jak chcesz obsłużyć oczekujące należy do Ciebie: Może odpytywania z [NSThread sleepForTimeInterval: 1] lub podobne, lub wysyłając wiadomość SELF każdej pętli run.

Answer 2

Moja pierwsza skłonność to nie robienie tego, co sugerujesz. Technika, której użyłem wcześniej, to nadanie wątkowi selektora do metody w obiekcie początkowym (który znajduje się w głównym wątku). Po uruchomieniu drugiego wątku główny wątek nadal wykonuje, ale wyświetla na wyświetlaczu jakiś zajęty wskaźnik. Pozwala to na kontynuację interakcji użytkownika, jeśli jest to wymagane.

Po zakończeniu drugiego wątku, tuż przed jego zamknięciem, wywoływana jest selektor głównego wątku. Metoda, którą odwołuje się selektor, usuwa wtedy wskaźnik zajętości z ekranu i informuje główny wątek do aktualizacji, zbierając dane, które wygenerował drugi wątek.

Z powodzeniem używam tej aplikacji, która uzyskuje dostęp do usługi sieciowej (w drugim wątku), a następnie aktualizuje ekran po zwrocie danych bez ich blokowania. To sprawia, że ​​użytkownik jest znacznie milszy.

Answer 3

Użyć NSOperationQueue, tak
(z pamięci więc wybaczyć jakieś drobne błędy - dostaniesz podstawową ideę):

// ivars 
NSOperationQueue *opQueue = [[NSOperationQueue alloc] init]; 
// count can be anything you like 
[opQueue setMaxConcurrentOperationCount:5]; 

- (void)main 
{ 
    [self doStuffInOperations]; 
} 

// method 
- (void)doStuffInOperations 
{ 
    // do parallel task A 
    [opQueue addOperation:[[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomething:) object:@"a"] autorelease]]; 

    // do parallel task B 
    [opQueue addOperation:[[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomething:) object:@"b"] autorelease]]; 

    // do parallel task C 
    [opQueue addOperation:[[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomething:) object:@"c"] autorelease]]; 


    [opQueue waitUntilAllOperationsHaveFinished]; 

    // now, do stuff that requires A, B, and C to be finished, and they should be finished much faster because they are in parallel. 
} 

- (void)doSomething:(id)arg 
{ 
    // do whatever you want with the arg here 
    // (which is in the background, 
    // because all NSOperations added to NSOperationQueues are.) 
} 

Answer 4

Oto kolejny sposób to zrobić przy użyciu GCD:

- (void)main 
{ 
    [self doStuffInOperations]; 
} 

- (void)doStuffInGCD 
{ 
    dispatch_group_t d_group = dispatch_group_create(); 
    dispatch_queue_t bg_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

    dispatch_group_async(d_group, bg_queue, ^{ 
     [self doSomething:@"a"]; 
    }); 

    dispatch_group_async(d_group, bg_queue, ^{ 
     [self doSomething:@"b"]; 
    }); 

    dispatch_group_async(d_group, bg_queue, ^{ 
     [self doSomething:@"c"]; 
    }); 


    // you can do this to synchronously wait on the current thread: 
    dispatch_group_wait(d_group, DISPATCH_TIME_FOREVER); 
    dispatch_release(d_group); 
    NSLog(@"All background tasks are done!!"); 


    // **** OR **** 

    // this if you just want something to happen after those are all done: 
    dispatch_group_notify(d_group, dispatch_get_main_queue(), ^{ 
     dispatch_release(d_group); 
     NSLog(@"All background tasks are done!!");   
    }); 
} 

- (void)doSomething:(id)arg 
{ 
    // do whatever you want with the arg here 
} 

Answer 5

Moja technika jest sprawdzenie, czy zadanie można uruchomić (jeżeli wątek tła jest zakończone), a jeśli nie można uruchomić następnie używam GCD spróbować ponownie po upływie:

- (void)doSomething 
{ 
    if (/* is the other thread done yet? */) { 
    double delayInSeconds = 2.0; 
    dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)); 
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){ 
     [self doSomething]; 
    }); 
    return; 
    } 

    // do something 
} 

Answer 6

Kilka technicznych sposobów synchronizacji wielu wątków, takich jak NSConditionLock (mutex-lock), NSCondition (semafor) .Jednak są one popularną wiedzą programistyczną dla innych języków (java ...) poza celem-c. Wolę przedstawić run loop (specjalne w Cocoa) w celu wdrożenia wątek dołączyć:

NSThread *A; //global 
A = [[NSThread alloc] initWithTarget:self selector:@selector(runA) object:nil]; //create thread A 
[A start]; 

- (void)runA  
{ 
　　[NSThread detachNewThreadSelector:@selector(runB) toTarget:self withObject:nil]; //create thread B  
　　while (1)  
　　{  
　　　　if ([[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]) //join here, waiting for thread B  
　　　　{  
　　　　　　NSLog(@"thread B quit...");  
　　　　　　break;  
　　　　}  
　　}  
} 

- (void)runB  
{  
　　sleep(1);  
　　[self performSelector:@selector(setData) onThread:A withObject:nil waitUntilDone:YES modes:@[NSDefaultRunLoopMode]];  
} 

Answer 7

W takich przypadkach zwykle za pomocą klasy NSCondition.

//this method executes in main thread/queue 
- (void)waitForJob 
{ 
    id __weak selfWeak = self; 
    NSCondition *waitHandle = [NSCondition new]; 
    [waitHandle lock]; 
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{ 
     [selfWeak doSomethingLongtime]; 
     [waitHandle signal]; 
    }); 
    //waiting for background thread finished 
    [waitHandle waitUntilDate:[NSDate dateWithTimeIntervalSinceNow:60]]; 
}