多个NSThreads同步:Multiple NSThreads synchronization

You should be careful when updating a variable from different threads. See the Synchronization section of the Threading Programming Guide. It's simplified when dealing with a fundamental data type like your counter (just make sure you declare it as atomic). But in more substantive scenarios, you'll want to employ some synchronization technique such as @synchronized, locks, dedicated custom serial queue, etc.

In general, if you're using threads (but not necessary if using queues), you should be creating an autorelease pool for your thread.

无论如何，撇开这些观察，您可能会有类似以下的内容，其中(a)的内容为@autoreleasepool； (b)循环； (c)使用锁来确保各个线程将其交互与size变量同步:

Anyway, with these observations aside, you might have something like the following, which (a) has @autoreleasepool; (b) loops; and (c) uses a lock to make sure that the various threads synchronize their interactions with the size variable:

- (void) workerThread:(id)obj { @autoreleasepool { BOOL done = NO; while (!done) { [self.lock lock]; if (size < 9) { size++; NSLog(@"Thread:%@--------Size:%d", obj, size); } else { done = YES; } [self.lock unlock]; // perhaps you're doing something time consuming here... } } } 

这假定您具有名为lock的NSLock属性:

This assumes you have NSLock property, called lock:

@property (nonatomic, strong) NSLock *lock; 

您是在启动线程测试之前创建的:

Which you created before initiating your thread test:

- (void) threadTest { size = 0; self.lock = [[NSLock alloc] init]; NSThread* T1 = [[NSThread alloc] initWithTarget:self selector:@selector(workerThread:) object:@"T1"]; [T1 start]; NSThread* T2 = [[NSThread alloc] initWithTarget:self selector:@selector(workerThread:) object:@"T2"]; [T2 start]; NSThread* T3 = [[NSThread alloc] initWithTarget:self selector:@selector(workerThread:) object:@"T3"]; [T3 start]; } 

已经说完了，您首先从将控制返回到主线程"开始.正如我之前所说，确实没有必要这样做，因为在您的示例中，应用程序的主线程从未产生控制权

Having said all this, you started this with "return control back to the main thread". As I said earlier, there's really no need to do that because in your example, your app's main thread never yielded control

For controlling relationships between tasks happening on different threads, I might suggest using GCD or operation queues. They're easier to use and have better mechanism for controlling dependencies between various tasks/operations (see Concurrency Programming Guide).

例如，考虑与上述workerThread方法相同的基于操作的方法(相同，但不需要自动释放池):

For example, consider the operation-based equivalent to your above workerThread method (identical, but no autorelease pool is needed):

- (void) operationMethod:(id)obj { BOOL done = NO; while (!done) { [self.lock lock]; if (size < 9) { size++; NSLog(@"Operation:%@--------Size:%d", obj, size); } else { done = YES; } [self.lock unlock]; // perhaps you're doing something time consuming here... } } 

然后您可以创建三个操作(可能将在三个线程上运行)并等待结果，如下所示:

You could then create three operations (which probably will run on three threads) and wait for the result, like so:

- (void) operationTestWait { size = 0; self.lock = [[NSLock alloc] init]; NSOperationQueue *queue = [[NSOperationQueue alloc] init]; NSOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op1"]; NSOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op2"]; NSOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op3"]; [queue addOperations:@[op1, op2, op3] waitUntilFinished:YES]; // do here whatever should happen when the operations are done } 

在这种情况下，主线程将等待这三个操作完成.

In this case, the main thread will wait for these three operations to finish.

或者，更好的是，如果这些任务花费了几毫秒的时间，则您不应该等待主队列(因为您应该从不阻塞主队列)，而是应该简单地定义完成这三个操作后，您希望主队列执行的操作:

Or, better, if these tasks take more than a few milliseconds, you should not have the main queue wait (since you should never block the main queue), but rather, you should simply define what you want the main queue to do when the three operations are done:

- (void) operationTest { size = 0; self.lock = [[NSLock alloc] init]; NSOperationQueue *queue = [[NSOperationQueue alloc] init]; NSOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op1"]; NSOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op2"]; NSOperation *op3 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationMethod:) object:@"Op3"]; NSOperation *completion = [NSBlockOperation blockOperationWithBlock:^{ // if you want this to do something on the main queue, then have this add it to the main queue [[NSOperationQueue mainQueue] addOperationWithBlock:^{ // do here whatever should happen when the operations are done }]; }]; // define this completion operation to be dependent upon the above three operations [completion addDependency:op1]; [completion addDependency:op2]; [completion addDependency:op3]; // now add all of them, but don't wait until finished; // but the completion operation will only start when its dependencies // are resolved [queue addOperations:@[op1, op2, op3, completion] waitUntilFinished:NO]; } 

请原谅冗长的答案.如果您可以为我们提供这些线程将要执行的操作的更实际示例，并且我们可以为如何最好地解决该问题提供更好的建议.但是，通常来说，操作队列或调度队列可能是解决大多数并发相关挑战的更有效方法.

Forgive the long-winded answer. If you can give us a more practical example of what these various threads will be doing and we can provide better counsel on how to best tackle it. But, in general, operation queues or dispatch queues will probably be more efficient way to tackle most concurrency related challenges.

这篇关于多个NSThreads同步的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程技术网(www.editcode.net)！